Renormalization Group for Urban Scaling

The renormalization group (RG) explains why cities obey power laws. By iteratively coarse-graining the urban density field and tracking how parameters flow, we show that the scaling exponent $\beta = 3/4$ from Module 1 is a universal fixed point—not an accident of network optimization but an inevitable consequence of scale invariance.

1. Coarse-Graining: Block-Spin Transformation

Consider a 2D urban density field $\rho(\mathbf{x})$ defined on a lattice with spacing $a$. The RG transformation consists of three steps:

Block: Group sites into blocks of $b \times b$ cells (where $b$ is the rescaling factor).
Average: Assign each block a coarse-grained density $\tilde{\rho}$ by averaging over the block:
$\tilde{\rho}_I = \frac{1}{b^d}\sum_{i \in \text{block } I}\rho_i$
Rescale: Shrink the lattice spacing back to $a$ by the substitution $\mathbf{x} \to \mathbf{x}/b$.

After one RG step, the system looks the same (same lattice spacing) but at a coarser scale. If the system is at a fixed point, the statistical properties are unchanged:

$$\mathcal{R}[\rho^*] = \rho^*$$

where $\mathcal{R}$ is the RG transformation operator. Fixed points correspond to scale-invariant states—the system looks the same at all scales.

2. Scaling Relations at the Fixed Point

Near the fixed point, the RG transformation acts linearly on deviations. An extensive quantity $\Lambda$ (such as total road length in a block) transforms under blocking by a factor $n_b = b^d$ (number of cells per block) as:

$$\Lambda(n_b \cdot N) = n_b^{\beta}\,\Lambda(N)$$

For infrastructure networks in $d$-dimensional embedding, the fixed-point condition requires that the network length scales sublinearly with the number of nodes served (since the network can be shared). The RG flow converges to:

$$\beta = 1 - \frac{1}{d}$$

For urban infrastructure embedded in $d = 3$ (accounting for the vertical dimension of buildings and underground utilities):

$$\beta = 1 - \frac{1}{3} = \frac{3}{4} = 0.75$$

This recovers the Bettencourt-West result from Module 1, but now we see it is deeperthan network optimization: it is the unique fixed point of the renormalization group flow. Any initial condition in the basin of attraction flows to this exponent under repeated coarse-graining.

3. Universality: Why Details Do Not Matter

The power of the RG approach is universality. The exponent $\beta = 3/4$ does not depend on:

The specific network topology (grid, hub-and-spoke, organic)
The optimization criterion (minimize total length, minimize travel time, minimize cost)
The detailed arrangement of buildings and roads
The history of how the city grew

It depends only on the embedding dimension $d$ and the extensive nature of the quantity being scaled. This is directly analogous to critical phenomena in statistical mechanics, where exponents depend only on symmetry and dimensionality, not on microscopic interactions.

The linearized RG at the fixed point defines relevant and irrelevant perturbations:

$$\delta\rho \to b^{y_i}\,\delta\rho, \qquad y_i > 0 \text{ (relevant)}, \quad y_i < 0 \text{ (irrelevant)}$$

Irrelevant perturbations (the detailed urban microstructure) wash out under coarse-graining. Relevant perturbations (population, embedding dimension) determine the universality class.

4. Tracing the RG Flow

We demonstrate the RG by iteratively coarse-graining a synthetic urban density field and measuring how the effective scaling exponent converges to the fixed point.

Renormalization Group Flow of Urban Density Field

Python

script.py159 lines

import numpy as np
import matplotlib.pyplot as plt

np.random.seed(42)

# --- Generate synthetic urban density field ---
# Use a fractal-like field (inverse FFT with power-law spectrum)
N0 = 512  # initial grid size
kx = np.fft.fftfreq(N0, d=1.0/N0)
ky = np.fft.fftfreq(N0, d=1.0/N0)
KX, KY = np.meshgrid(kx, ky)
K2 = KX**2 + KY**2
K2[0, 0] = 1  # avoid division by zero

# Power-law spectrum with some randomness
spectrum = K2**(-1.2) * np.exp(1j * 2*np.pi * np.random.random((N0, N0)))
spectrum[0, 0] = N0**2  # set mean density

rho0 = np.real(np.fft.ifft2(spectrum))
rho0 = rho0 - rho0.min() + 0.1  # ensure positive

# --- Block-spin RG transformation ---
def coarse_grain(field, b=2):
    """Block average with rescaling factor b."""
    N = field.shape[0]
    N_new = N // b
    coarse = np.zeros((N_new, N_new))
    for i in range(N_new):
        for j in range(N_new):
            block = field[i*b:(i+1)*b, j*b:(j+1)*b]
            coarse[i, j] = np.mean(block)
    return coarse

# --- Measure scaling: total "infrastructure" in boxes of size R ---
def measure_scaling(field, box_sizes):
    """Measure how total infrastructure (sum of density^beta_trial) scales."""
    N = field.shape[0]
    results = []
    for R in box_sizes:
        if R > N:
            continue
        n_boxes = N // R
        totals = []
        for i in range(n_boxes):
            for j in range(n_boxes):
                box = field[i*R:(i+1)*R, j*R:(j+1)*R]
                # "Infrastructure" = sum of density in box
                totals.append(np.sum(box))
        # Average total vs box population
        totals = np.array(totals)
        pops = totals  # population ~ density sum
        results.append((R**2, np.mean(totals)))
    return np.array(results)

# --- Apply successive RG steps ---
fields = [rho0]
for step in range(5):
    fields.append(coarse_grain(fields[-1], b=2))

# --- Measure exponent at each RG level ---
# Compare total density in region of size R to the number of cells
exponents = []
for level, field in enumerate(fields):
    N = field.shape[0]
    if N < 8:
        continue
    box_sizes = [2, 4, 8, 16]
    box_sizes = [b for b in box_sizes if b <= N//2]
    if len(box_sizes) < 3:
        continue

scaling = measure_scaling(field, box_sizes)
    if len(scaling) < 3:
        continue

log_n = np.log(scaling[:, 0])  # number of cells in box
    log_L = np.log(scaling[:, 1])  # total infrastructure

if len(log_n) >= 2:
        beta_est, _ = np.polyfit(log_n, log_L, 1)
        exponents.append((level, beta_est, N))

# --- Alternative: direct RG flow via variance ratio ---
# At fixed point, variance scales as: Var(rho_coarse)/Var(rho_fine) = b^{-2*y}
variance_ratios = []
for i in range(len(fields)-1):
    if fields[i].shape[0] < 4:
        break
    v_fine = np.var(fields[i])
    v_coarse = np.var(fields[i+1])
    if v_fine > 0:
        ratio = v_coarse / v_fine
        variance_ratios.append((i, ratio))

# --- Visualisation ---
fig, axes = plt.subplots(2, 3, figsize=(14, 9))

# Row 1: Density field at different RG levels
for idx, level in enumerate([0, 2, 4]):
    ax = axes[0, idx]
    if level < len(fields):
        im = ax.imshow(fields[level], cmap='YlGn', interpolation='nearest')
        ax.set_title(f'RG level {level} ({fields[level].shape[0]}x{fields[level].shape[0]})')
        ax.set_xticks([])
        ax.set_yticks([])
        plt.colorbar(im, ax=ax, fraction=0.046)

# (d) Scaling exponent convergence
ax = axes[1, 0]
if exponents:
    levels = [e[0] for e in exponents]
    betas = [e[1] for e in exponents]
    ax.plot(levels, betas, 'o-', color='teal', markersize=8, linewidth=2)
    ax.axhline(0.75, color='crimson', linestyle='--', linewidth=2, label='beta=3/4 (d=3)')
    ax.axhline(1.0, color='gray', linestyle=':', alpha=0.5, label='beta=1 (linear)')
    ax.set_xlabel('RG level')
    ax.set_ylabel('Measured exponent')
    ax.set_title('Exponent vs RG Level')
    ax.legend(fontsize=9)
else:
    ax.text(0.5, 0.5, 'Insufficient data', ha='center', va='center',
            transform=ax.transAxes, color='gray')

# (e) Variance ratio (RG flow diagnostic)
ax = axes[1, 1]
if variance_ratios:
    vr_levels = [v[0] for v in variance_ratios]
    vr_vals = [v[1] for v in variance_ratios]
    ax.plot(vr_levels, vr_vals, 's-', color='teal', markersize=8, linewidth=2)
    ax.set_xlabel('RG step')
    ax.set_ylabel('Var(coarse) / Var(fine)')
    ax.set_title('Variance Ratio Flow')
    ax.axhline(1.0, color='gray', linestyle=':', alpha=0.5)

# (f) Universal exponent vs dimension
ax = axes[1, 2]
d_vals = np.linspace(1.5, 5, 50)
beta_theory = 1 - 1/d_vals
ax.plot(d_vals, beta_theory, '-', color='teal', linewidth=2, label=r'beta = 1 - 1/d')
ax.plot(2, 1-1/2, 'o', color='#059669', markersize=12, label='d=2: beta=1/2')
ax.plot(3, 1-1/3, '*', color='crimson', markersize=15, label='d=3: beta=3/4')
ax.plot(4, 1-1/4, 's', color='gold', markersize=10, label='d=4: beta=3/4... wait, 7/8')
ax.set_xlabel('Embedding dimension d')
ax.set_ylabel('Scaling exponent beta')
ax.set_title('Universal Exponent')
ax.legend(fontsize=8)
ax.set_ylim(0.3, 1.05)

plt.tight_layout()
plt.savefig('output.png', dpi=130, bbox_inches='tight')
plt.show()

print("=== Renormalization Group Results ===")
print(f"Initial field: {N0}x{N0}")
for level, beta, N in exponents:
    print(f"  Level {level} ({N}x{N}): beta = {beta:.4f}")
print(f"\nTheoretical fixed point (d=3): beta = {3/4:.4f}")
print(f"Theoretical fixed point (d=2): beta = {1/2:.4f}")

Click Run to execute the Python code

Code will be executed with Python 3 on the server

5. Connecting the Modules

The RG provides the deepest understanding of the scaling laws encountered throughout this course:

Module 1 (Allometry): The exponent $\beta = 3/4$ was derived from network optimisation. The RG shows this is the only possible fixed point for $d=3$.
Module 3 (CA): Cellular automata generate spatial patterns that, under coarse-graining, flow to the same fixed point—regardless of the specific transition rules.
Module 8 (Fractals): DLA clusters have a fixed fractal dimension because the growth process is at an RG fixed point of the Laplacian field.
This chapter: The RG unifies these observations into a single framework of scale invariance and universality.

← Homogenization (CA-PDE)Equation-Free Methods →