Network Synchronization

Real urban systems are not all-to-all coupled: traffic signals interact along streets, commuters influence their neighbours, and economic activity propagates through spatial networks. The network Kuramoto model replaces the mean-field coupling with graph structure, and the critical coupling depends on the graph Laplacian—connecting directly to the spectral graph theory from Module 6.

1. Network Kuramoto Model

On a graph with adjacency matrix $A_{ij}$, the Kuramoto equations become:

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

Note that the coupling sum now runs only over neighbours of node $i$. For an unweighted graph, the coupling strength per link is $K$ (not $K/N$ as in the all-to-all case). The graph structure fundamentally changes the synchronization dynamics.

The degree heterogeneity of the network interacts with the frequency heterogeneity to produce rich phenomenology: hub nodes synchronize first, peripheral nodes last, and the network may fragment into synchronization clusters determined by its community structure.

2. Linearisation Near Synchrony

Near a synchronized state where all phases are close, we write $\theta_i = \bar{\theta} + \delta\theta_i$ with $|\delta\theta_i| \ll 1$. Linearising $\sin(\theta_j - \theta_i) \approx \delta\theta_j - \delta\theta_i$:

$$\frac{d(\delta\theta_i)}{dt} = \omega_i - \bar{\omega} + K \sum_j A_{ij} (\delta\theta_j - \delta\theta_i)$$

Recognising the graph Laplacian $L_{ij} = D_{ij} - A_{ij}$ where $D = \text{diag}(k_1, \dots, k_N)$ is the degree matrix:

$$\frac{d(\delta\boldsymbol{\theta})}{dt} = (\boldsymbol{\omega} - \bar{\omega}\mathbf{1}) - KL \, \delta\boldsymbol{\theta}$$

This is a forced linear system. The Laplacian eigenvalues $0 = \lambda_1 \leq \lambda_2 \leq \dots \leq \lambda_N$ determine stability. The zero eigenvalue corresponds to a uniform phase shift (gauge freedom). Stability of the synchronized state requires the forcing term to be balanced by the restoring force from the Laplacian.

3. Critical Coupling and the Fiedler Value

The algebraic connectivity or Fiedler value $\lambda_2(L)$ is the smallest non-zero eigenvalue of the Laplacian. It governs the rate of synchronization. The critical coupling on a graph is approximately:

$$K_c^{\text{graph}} = \frac{\Delta\omega}{\lambda_2(L)}$$

where $\Delta\omega$ is the effective spread of natural frequencies (e.g., the width of the frequency distribution projected onto the Fiedler eigenvector). This formula has a beautiful interpretation:

Large $\lambda_2$ (well-connected graph): Low critical coupling. The network easily synchronizes. Small-world and complete graphs have large $\lambda_2$.
Small $\lambda_2$ (poorly connected graph): High critical coupling. The network resists synchronization. Trees and chains have small $\lambda_2 \sim 1/N^2$.

This connects directly to the spectral graph theory developed in Module 6: the Fiedler value that measured graph connectivity and determined the Cheeger isoperimetric constant now also determines how easily a network of urban oscillators can synchronize.

Connection to Module 6

Recall that $\lambda_2$ satisfies the Cheeger inequality: $\lambda_2/2 \leq h(G) \leq \sqrt{2\lambda_2}$ where $h(G)$ is the isoperimetric number. A network bottleneck (small $h$) means small $\lambda_2$ and hence high critical coupling—the bottleneck impedes synchronization just as it impedes diffusion.

4. Chimera States

One of the most striking phenomena in network synchronization is the chimera state: the spontaneous coexistence of synchronized and desynchronized clusters in a population of identical oscillators on a symmetric network.

In the urban context, chimera states can explain why neighbouring districts sometimes exhibit starkly different rhythms despite similar demographics and infrastructure: one district's traffic flows smoothly while the adjacent one is gridlocked, even with symmetric road networks.

Chimera states require nonlocal coupling (each oscillator couples to a range of neighbours, not just nearest) and arise from a symmetry-breaking instability. The coherent cluster has $r_{\text{local}} \approx 1$ while the incoherent cluster has $r_{\text{local}} \ll 1$, despite identical oscillator parameters.

5. Network Topology and Synchronization Threshold

We simulate the network Kuramoto model on three topologies—grid, small-world, and scale-free—and compare their synchronization transitions, verifying the role of$\lambda_2$.

Network Kuramoto: Topology-Dependent Synchronization Transitions

Python

script.py184 lines

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

np.random.seed(123)

N = 50  # nodes per network

# --- Build Networks ---

def grid_adjacency(n):
    """2D grid (sqrt(n) x sqrt(n))."""
    side = int(np.sqrt(n))
    A = np.zeros((n, n))
    for i in range(n):
        r, c = i // side, i % side
        if r > 0: A[i, i - side] = 1
        if r < side - 1: A[i, i + side] = 1
        if c > 0: A[i, i - 1] = 1
        if c < side - 1: A[i, i + 1] = 1
    return A

def small_world_adjacency(n, k=4, p=0.3):
    """Watts-Strogatz small-world."""
    A = np.zeros((n, n))
    for i in range(n):
        for j in range(1, k // 2 + 1):
            A[i, (i + j) % n] = 1
            A[i, (i - j) % n] = 1
    # Rewire
    for i in range(n):
        for j in range(1, k // 2 + 1):
            if np.random.rand() < p:
                A[i, (i + j) % n] = 0
                A[(i + j) % n, i] = 0
                new_j = np.random.randint(n)
                while new_j == i or A[i, new_j] == 1:
                    new_j = np.random.randint(n)
                A[i, new_j] = 1
                A[new_j, i] = 1
    return A

def scale_free_adjacency(n, m=2):
    """Barabasi-Albert scale-free."""
    A = np.zeros((n, n))
    # Start with complete graph on m+1 nodes
    for i in range(m + 1):
        for j in range(i + 1, m + 1):
            A[i, j] = A[j, i] = 1
    degrees = np.sum(A, axis=1)
    for i in range(m + 1, n):
        probs = degrees[:i] / np.sum(degrees[:i])
        targets = np.random.choice(i, size=m, replace=False, p=probs)
        for t in targets:
            A[i, t] = A[t, i] = 1
        degrees = np.sum(A, axis=1)
    return A

def graph_laplacian(A):
    D = np.diag(np.sum(A, axis=1))
    return D - A

def compute_lambda2(A):
    L = graph_laplacian(A)
    eigs = np.sort(np.real(np.linalg.eigvalsh(L)))
    return eigs[1]

# Build networks
N_grid = 49  # 7x7
A_grid = grid_adjacency(N_grid)
A_sw = small_world_adjacency(N)
A_sf = scale_free_adjacency(N)

networks = {
    'Grid (7x7)': (A_grid, N_grid),
    'Small-World': (A_sw, N),
    'Scale-Free': (A_sf, N),
}

# Compute Fiedler values
print("=== Network Properties ===")
for name, (A, n) in networks.items():
    lam2 = compute_lambda2(A)
    avg_deg = np.mean(np.sum(A, axis=1))
    print(f"{name}: lambda_2 = {lam2:.4f}, avg degree = {avg_deg:.1f}")

# --- Simulate Kuramoto on each network ---
gamma = 0.5
K_values = np.linspace(0, 3.0, 25)

def simulate_network_kuramoto(A, n, K, omega, T_trans=40, T_meas=20):
    def rhs(t, theta):
        dtheta = omega.copy()
        for i in range(n):
            for j in range(n):
                if A[i, j] > 0:
                    dtheta[i] += K * A[i, j] * np.sin(theta[j] - theta[i])
        return dtheta

theta0 = 2 * np.pi * np.random.rand(n)
    sol = solve_ivp(rhs, [0, T_trans + T_meas], theta0,
                    t_eval=np.linspace(T_trans, T_trans + T_meas, 30),
                    method='RK45', max_step=0.5)
    r_vals = []
    for k in range(sol.y.shape[1]):
        z = np.mean(np.exp(1j * sol.y[:, k]))
        r_vals.append(np.abs(z))
    return np.mean(r_vals)

results = {}
for name, (A, n) in networks.items():
    omega = gamma * np.tan(np.pi * (np.random.rand(n) - 0.5))
    omega = np.clip(omega, -5, 5)
    r_vals = []
    print(f"\nSimulating {name}...")
    for K in K_values:
        r = simulate_network_kuramoto(A, n, K, omega)
        r_vals.append(r)
    results[name] = np.array(r_vals)

# Estimate critical coupling
print("\n=== Critical Coupling Estimates ===")
for name, (A, n) in networks.items():
    lam2 = compute_lambda2(A)
    K_c_theory = 2 * gamma / lam2 if lam2 > 0 else float('inf')
    # Empirical: first K where r > 0.3
    r_arr = results[name]
    idx = np.where(r_arr > 0.3)[0]
    K_c_emp = K_values[idx[0]] if len(idx) > 0 else float('inf')
    print(f"{name}: K_c (theory ~ Delta_omega/lambda_2) = {K_c_theory:.2f}, K_c (empirical r>0.3) = {K_c_emp:.2f}")

# --- Plot ---
fig, axes = plt.subplots(1, 3, figsize=(15, 5))
colors_net = ['#10b981', '#f59e0b', '#06b6d4']
markers = ['o', 's', '^']

# Synchronization curves
ax = axes[0]
for idx, (name, r_vals) in enumerate(results.items()):
    ax.plot(K_values, r_vals, color=colors_net[idx], marker=markers[idx],
            markersize=4, linewidth=2, label=name, alpha=0.8)
ax.set_xlabel('Coupling K', fontsize=12, color='white')
ax.set_ylabel('Order parameter r', fontsize=12, color='white')
ax.set_title('Sync Transition by Topology', fontsize=14, color='white', fontweight='bold')
ax.legend(fontsize=10)
ax.set_facecolor('#0a0a0a')
ax.tick_params(colors='white')
ax.grid(True, alpha=0.2)

# Lambda_2 bar chart
ax = axes[1]
lam2_vals = [compute_lambda2(networks[name][0]) for name in networks]
bars = ax.bar(range(3), lam2_vals, color=colors_net, alpha=0.8)
ax.set_xticks(range(3))
ax.set_xticklabels([n.split('(')[0].strip() for n in networks.keys()], fontsize=10, color='white')
ax.set_ylabel('Fiedler value (lambda_2)', fontsize=12, color='white')
ax.set_title('Algebraic Connectivity', fontsize=14, color='white', fontweight='bold')
ax.set_facecolor('#0a0a0a')
ax.tick_params(colors='white')
ax.grid(True, alpha=0.2, axis='y')

# Laplacian spectra
ax = axes[2]
for idx, (name, (A, n)) in enumerate(networks.items()):
    L = graph_laplacian(A)
    eigs = np.sort(np.real(np.linalg.eigvalsh(L)))
    ax.plot(range(len(eigs)), eigs, color=colors_net[idx], linewidth=2,
            label=name, alpha=0.8)
ax.set_xlabel('Eigenvalue index', fontsize=12, color='white')
ax.set_ylabel('Laplacian eigenvalue', fontsize=12, color='white')
ax.set_title('Laplacian Spectra', fontsize=14, 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("\nPlot saved: network synchronization comparison")

Click Run to execute the Python code

Code will be executed with Python 3 on the server

6. Multi-Scale Synchronization in Urban Networks

Urban networks exhibit hierarchical structure: local streets connect to collectors, which connect to arterials, which connect to highways. Each level has characteristic coupling strengths and timescales. The network Kuramoto model on such hierarchical graphs producesmulti-scale synchronization:

Local sync (low K): Neighbouring intersections along a single street synchronize first, forming local platoons.
Arterial sync (moderate K): Adjacent street segments coordinate, forming arterial Green Waves.
Network sync (high K): The entire network achieves global coordination, but this requires very strong coupling and is rarely achieved in practice.

The cascade of synchronization transitions is governed by the spectral gap structure of the hierarchical Laplacian: each level of the hierarchy contributes a cluster of eigenvalues, and synchronization propagates from the largest eigenvalue gaps (strongest connections) to the smallest (weakest connections).

Key Takeaway

Network topology fundamentally shapes synchronization. The Fiedler value $\lambda_2$ determines the critical coupling, connecting synchronization theory to spectral graph theory. Small-world networks synchronize easily (large $\lambda_2$); sparse grids require strong coupling. Chimera states explain how neighbouring urban districts can exhibit fundamentally different dynamics on identical infrastructure.

← Kuramoto Model Urban Synchronization →