Urban Synchronization

The Kuramoto framework is not merely an analogy for urban systems—it provides a precise mathematical model for two of the most important coordination phenomena in cities: the Green Wave in traffic signal timing and the morning commute peak as a synchronization phase transition. Breaking synchronization by reducing coupling can be as powerful as adding capacity.

1. Green Wave as a Phase-Locked State

Consider a corridor of $n$ traffic signals, each cycling with period $T_c$ and phase $\theta_i$. Each signal is an oscillator with natural frequency $\omega_i = 2\pi/T_c$ (identical for coordinated signals). The coupling arises from platoon interactions: vehicles departing intersection $i$ on green arrive at intersection $i+1$ after travel time $\tau_i$.

The Green Wave is the phase-locked state where each signal's phase is offset by the travel time from the first intersection:

$$\theta_i = \theta_0 + \frac{2\pi d_i}{v_{\text{wave}} T_c}$$

where $d_i$ is the distance from the first intersection and $v_{\text{wave}}$ is the design progression speed. In Kuramoto notation, this is a frequency-locked solution with phase differences:

$$\Delta\theta_{i,i+1} = \theta_{i+1} - \theta_i = \frac{2\pi \tau_i}{T_c} = \omega_0 \tau_i$$

The locked state exists when the coupling strength (traffic signal coordination mechanism) exceeds the critical coupling $K > K_c$. Without coordination ($K = 0$), signals run independently and drivers encounter random red/green sequences.

2. Morning Commute Peak as Kuramoto Transition

Model each commuter $i$ as an oscillator with “natural frequency” $\omega_i$ equal to their preferred departure time (in angular units over 24 hours). The coupling arises from social and institutional synchronization:

Work start times: Concentrated around 8-9 AM, providing a strong coupling signal.
School schedules: Another synchronizing force with slightly different phase.
Social norms: Desire to arrive when colleagues are present, meetings start on time.

The Kuramoto model for $N$ commuters:

$$\frac{d\theta_i}{dt} = \omega_i + \frac{K}{N} \sum_{j=1}^N \sin(\theta_j - \theta_i)$$

When $K > K_c$, a large fraction of commuters synchronize their departure times, creating the rush hour peak. The order parameter $r$ measures the “peakedness” of the commute distribution:

$r \approx 0$: Departures spread uniformly throughout the morning. No peak.
$r \approx 1$: Everyone departs simultaneously. Maximum congestion.

3. Flexible Schedules: Reducing K Below K_c

The profound insight from the Kuramoto framework is that reducing coupling strength is equivalent to adding capacity. Policies that reduce $K$ below $K_c$ break the synchronization and eliminate the rush hour peak entirely:

Flexible work hours: Broadening the distribution of preferred departure times (increasing $\Delta\omega$) increases $K_c = 2/(\pi g(0))$, effectively requiring more coupling to synchronize.
Remote work: Removing oscillators from the coupled population entirely. Fewer commuters means less collective synchronization pressure.
Staggered start times: Directly increasing the spread $\Delta\omega$ by institutional design.
Congestion pricing: Adding a cost that penalises peak-time travel, creating an effective repulsive coupling that opposes synchronization.

The critical insight is that this is a genuine phase transition, not a gradual smoothing. Once $K$ drops below $K_c$, the synchronized peak collapses discontinuously (for finite populations) or via the square-root law (in the mean-field limit).

4. Simulating Green Wave and Commute Peak

We simulate both phenomena: (a) Green Wave synchronization in a 5-intersection corridor, and (b) commute peak formation as coupling strength varies, showing how flexibility (reduced K) smooths the peak via a genuine phase transition.

Green Wave Synchronization and Commute Peak Phase Transition

Python

script.py192 lines

import numpy as np
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
from scipy.integrate import solve_ivp

np.random.seed(42)

# ============================================
# Part A: Green Wave Synchronization
# ============================================
n_signals = 5
T_cycle = 60.0  # cycle length (seconds)
omega0 = 2 * np.pi / T_cycle  # common frequency
spacings = np.array([0, 300, 550, 850, 1100])  # meters from first signal
v_wave = 15.0  # design speed m/s

# Ideal Green Wave offsets
ideal_offsets = spacings / v_wave  # seconds
ideal_phases = (2 * np.pi * ideal_offsets / T_cycle) % (2 * np.pi)

# Kuramoto model for signal coordination
def signal_kuramoto(t, theta, K):
    dtheta = np.full(n_signals, omega0)
    for i in range(n_signals):
        for j in range(n_signals):
            if abs(i - j) == 1:  # nearest-neighbour coupling
                dtheta[i] += K * np.sin(theta[j] - theta[i])
    return dtheta

# Simulate for different K values
T_sim = 300.0
theta0_random = 2 * np.pi * np.random.rand(n_signals)
K_green = [0.0, 0.3, 1.0, 3.0]
green_results = {}

for K in K_green:
    sol = solve_ivp(lambda t, y: signal_kuramoto(t, y, K),
                    [0, T_sim], theta0_random,
                    t_eval=np.linspace(0, T_sim, 500),
                    method='RK45', max_step=1.0)
    green_results[K] = sol

# ============================================
# Part B: Commute Peak as Phase Transition
# ============================================
N_commuters = 150
gamma_commute = 0.5  # width of preferred times (hours)

# Preferred departure times ~ 8 AM +/- gamma (in angular units)
omega_commute = gamma_commute * np.tan(np.pi * (np.random.rand(N_commuters) - 0.5))
omega_commute = np.clip(omega_commute, -3, 3)

def commute_kuramoto(t, theta, K):
    dtheta = omega_commute.copy()
    z = np.mean(np.exp(1j * theta))
    r = np.abs(z)
    psi = np.angle(z)
    dtheta += K * r * np.sin(psi - theta)
    return dtheta

# Sweep K for commute peak
K_commute_vals = np.linspace(0, 4.0, 30)
r_commute = np.zeros(len(K_commute_vals))
departure_spread = np.zeros(len(K_commute_vals))

for idx, K in enumerate(K_commute_vals):
    theta0 = 2 * np.pi * np.random.rand(N_commuters)
    sol = solve_ivp(lambda t, y: commute_kuramoto(t, y, K),
                    [0, 100], theta0,
                    t_eval=np.linspace(80, 100, 20),
                    method='RK45', max_step=1.0)
    r_vals = [np.abs(np.mean(np.exp(1j * sol.y[:, k]))) for k in range(sol.y.shape[1])]
    r_commute[idx] = np.mean(r_vals)
    # Spread: circular standard deviation
    final_theta = sol.y[:, -1] % (2 * np.pi)
    R = np.abs(np.mean(np.exp(1j * final_theta)))
    departure_spread[idx] = np.sqrt(-2 * np.log(max(R, 0.01)))

K_c_commute = 2 * gamma_commute
print(f"Commute K_c = {K_c_commute:.2f}")

# ============================================
# Part C: Effect of Flexibility
# ============================================
flexibility_levels = [0.3, 0.5, 1.0, 2.0]  # gamma values
flex_results = {}
K_flex = np.linspace(0, 5, 25)

for gam in flexibility_levels:
    omega_flex = gam * np.tan(np.pi * (np.random.rand(N_commuters) - 0.5))
    omega_flex = np.clip(omega_flex, -5, 5)
    r_flex = []
    for K in K_flex:
        def rhs_flex(t, theta, K=K, om=omega_flex):
            z = np.mean(np.exp(1j * theta))
            return om + K * np.abs(z) * np.sin(np.angle(z) - theta)
        theta0 = 2 * np.pi * np.random.rand(N_commuters)
        sol = solve_ivp(rhs_flex, [0, 80], theta0,
                        t_eval=[80], method='RK45', max_step=1.0)
        z_final = np.mean(np.exp(1j * sol.y[:, -1]))
        r_flex.append(np.abs(z_final))
    flex_results[gam] = np.array(r_flex)

# --- Plot ---
fig, axes = plt.subplots(2, 2, figsize=(14, 10))

# Green Wave: phase evolution
ax = axes[0, 0]
K_show = 3.0
sol_show = green_results[K_show]
colors_sig = ['#10b981', '#14b8a6', '#06b6d4', '#0ea5e9', '#6366f1']
for i in range(n_signals):
    phases = (sol_show.y[i, :] % (2 * np.pi)) / (2 * np.pi) * T_cycle
    ax.plot(sol_show.t, phases, color=colors_sig[i], linewidth=2,
            label=f'Signal {i+1} ({spacings[i]}m)')
# Draw ideal offsets
for i in range(n_signals):
    ax.axhline(y=(ideal_phases[i] / (2*np.pi)) * T_cycle, color=colors_sig[i],
               linestyle='--', alpha=0.4)
ax.set_xlabel('Time (s)', color='white')
ax.set_ylabel('Phase offset (s within cycle)', color='white')
ax.set_title(f'Green Wave Formation (K={K_show})', color='white', fontweight='bold')
ax.legend(fontsize=8, loc='upper right')
ax.set_facecolor('#0a0a0a')
ax.tick_params(colors='white')
ax.grid(True, alpha=0.2)

# Commute peak transition
ax = axes[0, 1]
ax.plot(K_commute_vals, r_commute, 'o-', color='#10b981', markersize=5, linewidth=2)
ax.axvline(x=K_c_commute, color='#ef4444', linestyle='--', linewidth=1.5,
           label=f'$K_c = {K_c_commute:.1f}$')
ax.set_xlabel('Social coupling K', color='white', fontsize=12)
ax.set_ylabel('Peak concentration r', color='white', fontsize=12)
ax.set_title('Commute Peak as Phase Transition', color='white', fontweight='bold')
ax.legend(fontsize=11)
ax.set_facecolor('#0a0a0a')
ax.tick_params(colors='white')
ax.grid(True, alpha=0.2)

# Departure time distributions
ax = axes[1, 0]
K_examples = [0.5, 2.0, 4.0]
colors_k = ['#10b981', '#f59e0b', '#ef4444']
for idx, K in enumerate(K_examples):
    theta0 = 2 * np.pi * np.random.rand(N_commuters)
    sol = solve_ivp(lambda t, y, K=K: commute_kuramoto(t, y, K),
                    [0, 100], theta0,
                    t_eval=[100], method='RK45', max_step=1.0)
    final = (sol.y[:, -1] % (2*np.pi)) * 24 / (2*np.pi)  # convert to hours
    ax.hist(final, bins=30, color=colors_k[idx], alpha=0.5, label=f'K={K}',
            density=True, range=(0, 24))
ax.set_xlabel('Departure time (hours)', color='white')
ax.set_ylabel('Density', color='white')
ax.set_title('Departure Distributions', color='white', fontweight='bold')
ax.legend(fontsize=10)
ax.set_facecolor('#0a0a0a')
ax.tick_params(colors='white')
ax.grid(True, alpha=0.2)

# Effect of flexibility
ax = axes[1, 1]
flex_colors = ['#ef4444', '#f59e0b', '#10b981', '#06b6d4']
for idx, gam in enumerate(flexibility_levels):
    K_c_flex = 2 * gam
    ax.plot(K_flex, flex_results[gam], color=flex_colors[idx], linewidth=2,
            label=f'gamma={gam} (K_c={K_c_flex:.1f})')
ax.set_xlabel('Social coupling K', color='white', fontsize=12)
ax.set_ylabel('Peak concentration r', color='white', fontsize=12)
ax.set_title('Flexibility Breaks the Peak', color='white', fontweight='bold')
ax.legend(fontsize=9)
ax.set_facecolor('#0a0a0a')
ax.tick_params(colors='white')
ax.grid(True, alpha=0.2)

fig.patch.set_facecolor('#0f172a')
plt.tight_layout()
plt.savefig('output.png', dpi=120, bbox_inches='tight', facecolor='#0f172a')
plt.close()

print("\n=== Summary ===")
print(f"Green Wave: {n_signals} signals, spacing = {spacings} m, v_wave = {v_wave} m/s")
print(f"Ideal phase offsets: {np.round(ideal_offsets, 1)} seconds")
print(f"\nCommute Peak: N = {N_commuters} commuters")
print(f"K_c = {K_c_commute:.2f}")
print(f"r at K=0.5: {r_commute[np.argmin(np.abs(K_commute_vals-0.5))]:.3f}")
print(f"r at K=4.0: {r_commute[-1]:.3f}")
print(f"\nFlexibility effect: increasing gamma from {flexibility_levels[0]} to {flexibility_levels[-1]}")
print(f"raises K_c from {2*flexibility_levels[0]:.1f} to {2*flexibility_levels[-1]:.1f}")
print("\nPlot saved: urban synchronization phenomena")

Click Run to execute the Python code

Code will be executed with Python 3 on the server

5. Quantitative Policy Implications

The Kuramoto framework provides quantitative predictions for urban policy. Consider a city where 80% of workers have rigid 9-to-5 schedules (narrow frequency distribution, $\gamma = 0.3$ hours) and social coupling $K = 2.0$:

$$K_c = 2\gamma = 0.6, \quad K/K_c = 3.33 \gg 1$$

The system is deeply in the synchronized phase with $r \approx \sqrt{1 - 0.6/2.0} = 0.84$—a sharp commute peak. Now suppose flexible scheduling doubles the spread to $\gamma = 1.0$:

$$K_c^{\text{new}} = 2.0, \quad K/K_c = 1.0$$

The system is now at the critical point! Just slightly more flexibility would push $K < K_c$ and collapse the peak entirely. The peak concentration drops from $r = 0.84$ to $r \approx 0$—not gradually, but as a phase transition.

Key Takeaway

Urban synchronization provides a unified framework: the Green Wave is a desired locked state (increase $K$ above $K_c$), while the commute peak is an undesired locked state (decrease $K$ below $K_c$). The same mathematical framework prescribes opposite interventions for opposite goals: strengthen coupling for traffic signals, weaken it for commuter schedules.

← Network Synchronization Part 15: Topological Data Analysis →