Simplicial Homology

Homology translates the intuitive notions of “holes” in a space into rigorous algebra. For urban networks, the Betti numbers count connected components, independent loops, and enclosed regions—topological invariants that distinguish fundamentally different city morphologies, from dense grids to sprawling trees.

1. Simplicial Complexes

A simplicial complex is the combinatorial scaffolding on which homology is built. It generalises the notion of a graph to higher dimensions:

0-simplex (vertex): A point. In the urban context: an intersection, a building, a landmark.
1-simplex (edge): A line segment connecting two vertices. A street segment, a transit link.
2-simplex (triangle): A filled triangle with three vertices and three edges. A city block, a plaza, a triangular intersection.
k-simplex: The convex hull of $k+1$ affinely independent points, denoted $[v_0, v_1, \dots, v_k]$.

A simplicial complex $\mathcal{K}$ is a collection of simplices closed under taking faces: if $\sigma \in \mathcal{K}$ and $\tau$ is a face of $\sigma$, then $\tau \in \mathcal{K}$. In plain terms: if a triangle is in the complex, then so are its three edges and three vertices.

2. Chain Groups and the Boundary Operator

The chain group $C_k$ is the free abelian group generated by all $k$-simplices. Working over $\mathbb{Z}_2$ (coefficients mod 2) simplifies orientation issues. A $k$-chain is a formal sum of $k$-simplices.

The boundary operator $\partial_k : C_k \to C_{k-1}$ maps each simplex to its oriented boundary:

$$\partial_k [v_0, v_1, \dots, v_k] = \sum_{i=0}^k (-1)^i [v_0, \dots, \hat{v}_i, \dots, v_k]$$

where $\hat{v}_i$ means vertex $v_i$ is omitted. The key examples:

$$\partial_1 [v_0, v_1] = v_1 - v_0$$

The boundary of an edge is its two endpoints (with signs from orientation). For a triangle:

$$\partial_2 [v_0, v_1, v_2] = [v_1, v_2] - [v_0, v_2] + [v_0, v_1]$$

The boundary of a triangle is the sum of its three edges (with consistent orientation).

3. The Fundamental Property: Boundary of a Boundary Is Zero

The essential algebraic fact underlying all of homology theory is:

$$\partial_{k-1} \circ \partial_k = 0$$

Verify for a triangle: applying $\partial_1$ to $\partial_2[v_0,v_1,v_2]$:

$$\partial_1 \partial_2 [v_0,v_1,v_2] = (v_2 - v_1) - (v_2 - v_0) + (v_1 - v_0) = 0$$

This means: every boundary is a cycle, but not every cycle is a boundary. The gap between cycles and boundaries is precisely what homology measures. The chain complex is:

$$\cdots \xrightarrow{\partial_3} C_2 \xrightarrow{\partial_2} C_1 \xrightarrow{\partial_1} C_0 \xrightarrow{\partial_0} 0$$

4. Homology Groups and Betti Numbers

Define the cycle group and boundary group:

$$Z_k = \ker \partial_k = \{c \in C_k : \partial_k c = 0\}$$

$$B_k = \text{im} \, \partial_{k+1} = \{\partial_{k+1} c : c \in C_{k+1}\}$$

Since $\partial^2 = 0$, we have $B_k \subseteq Z_k$. The $k$-th homology group is the quotient:

$$H_k = Z_k / B_k = \frac{\ker \partial_k}{\text{im} \, \partial_{k+1}}$$

The Betti numbers are the ranks of these groups:

$$\beta_k = \text{rank}(H_k) = \dim(Z_k) - \dim(B_k)$$

$\beta_0$: Number of connected components. How many separate pieces the network has.
$\beta_1$: Number of independent loops (cycles that are not boundaries of filled regions). Route redundancy in the network.
$\beta_2$: Number of enclosed voids (cavities). Rare in planar urban networks but relevant for 3D structures (tunnels, overpasses).

For a connected planar graph, the Euler relation gives $\beta_0 - \beta_1 + \beta_2 = V - E + F$ where $V, E, F$ are vertices, edges, and faces. For a graph (no 2-simplices), $\beta_1 = E - V + \beta_0$ counts the independent cycles by the cycle rank formula.

5. Five Urban Morphologies and Their Betti Numbers

Different city types produce characteristic topological signatures. Here we compare five canonical urban forms:

Urban Form	$\beta_0$	$\beta_1$	Signature
Grid (Manhattan)	1	High	Many independent loops; high redundancy
Radial + Ring (Paris)	1	Moderate	Loops from ring roads; radials are tree-like
Organic/Medieval	1	Low-Moderate	Irregular loops; some dead-ends
Suburban Sprawl	High	Low	Many cul-de-sacs; tree-like; fragmented
Polycentric	Low	Moderate-High	Multiple cores connected by loops

The key topological distinction: grids maximise $\beta_1$ (route choice), while sprawl maximises $\beta_0$ (fragmentation) and minimises $\beta_1$ (no alternative routes).

6. Computing Betti Numbers for Urban Networks

We build simplicial complexes for each urban form, compute the boundary matrices, and extract the Betti numbers via rank computations over $\mathbb{Z}_2$.

Computing Betti Numbers for Five Urban Morphologies

Python

script.py238 lines

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

def compute_betti_graph(edges, n_vertices):
    """Compute beta_0 and beta_1 for a graph using Union-Find and cycle rank."""
    # beta_0 via Union-Find
    parent = list(range(n_vertices))
    rank = [0] * n_vertices

def find(x):
        while parent[x] != x:
            parent[x] = parent[parent[x]]
            x = parent[x]
        return x

def union(a, b):
        ra, rb = find(a), find(b)
        if ra == rb:
            return False
        if rank[ra] < rank[rb]:
            ra, rb = rb, ra
        parent[rb] = ra
        if rank[ra] == rank[rb]:
            rank[ra] += 1
        return True

n_edges = len(edges)
    for u, v in edges:
        union(u, v)

components = len(set(find(i) for i in range(n_vertices)))
    beta_0 = components
    beta_1 = n_edges - n_vertices + beta_0  # cycle rank formula

return beta_0, beta_1

# ============================================
# Build Five Urban Network Types
# ============================================

def build_grid(side=7):
    """Manhattan-style grid."""
    n = side * side
    edges = []
    for i in range(side):
        for j in range(side):
            v = i * side + j
            if j < side - 1: edges.append((v, v + 1))
            if i < side - 1: edges.append((v, v + side))
    return n, edges

def build_radial_ring(n_radials=8, n_rings=4, pts_per_radial=5):
    """Paris-style radial + ring."""
    vertices = {(0, 0): 0}
    idx = 1
    edges = []

# Create radial points
    for r in range(n_radials):
        angle = 2 * np.pi * r / n_radials
        prev = 0
        for ring in range(1, n_rings + 1):
            x = ring * np.cos(angle)
            y = ring * np.sin(angle)
            vertices[(r, ring)] = idx
            edges.append((prev, idx))
            prev = idx
            idx += 1

# Create ring connections
    for ring in range(1, n_rings + 1):
        for r in range(n_radials):
            v1 = vertices[(r, ring)]
            v2 = vertices[((r + 1) % n_radials, ring)]
            edges.append((v1, v2))

return idx, edges

def build_organic(n=50, p_connect=0.08):
    """Medieval/organic layout - irregular connections."""
    np.random.seed(10)
    positions = np.random.rand(n, 2) * 10
    edges = []
    for i in range(n):
        for j in range(i + 1, n):
            dist = np.linalg.norm(positions[i] - positions[j])
            if dist < 2.0 and np.random.rand() < p_connect * 5:
                edges.append((i, j))
            elif dist < 1.2:
                edges.append((i, j))
    return n, edges, positions

def build_sprawl(n_clusters=5, pts_per_cluster=8):
    """Suburban sprawl - tree-like with cul-de-sacs."""
    edges = []
    n = 0
    cluster_centers = []

# Central node
    n = 1
    for c in range(n_clusters):
        center = n
        cluster_centers.append(center)
        edges.append((0, center))
        n += 1
        # Tree branches from cluster center
        for _ in range(pts_per_cluster):
            edges.append((center, n))
            # Some branches extend further
            if np.random.rand() < 0.4:
                leaf = n
                n += 1
                edges.append((leaf, n))
            n += 1

# Very few cross-connections (cul-de-sac structure)
    return n, edges

def build_polycentric(n_centers=3, pts_per_center=10):
    """Multiple connected cores."""
    n = 0
    edges = []
    centers = []

for c in range(n_centers):
        center = n
        centers.append(center)
        n += 1
        # Dense local grid around each center
        for i in range(pts_per_center):
            edges.append((center, n))
            if i > 0:
                edges.append((n - 1, n))
            n += 1
        # Close the loop
        edges.append((center + 1, n - 1))

# Connect centers
    for i in range(n_centers):
        for j in range(i + 1, n_centers):
            edges.append((centers[i], centers[j]))
            # Add parallel path
            mid = n
            n += 1
            edges.append((centers[i], mid))
            edges.append((mid, centers[j]))

return n, edges

# Build all networks
np.random.seed(42)
networks = {}

n_v, e = build_grid(7)
networks['Grid\n(Manhattan)'] = (n_v, e, compute_betti_graph(e, n_v))

n_v, e = build_radial_ring()
networks['Radial+Ring\n(Paris)'] = (n_v, e, compute_betti_graph(e, n_v))

n_v, e, pos = build_organic()
networks['Organic\n(Medieval)'] = (n_v, e, compute_betti_graph(e, n_v))

n_v, e = build_sprawl()
networks['Suburban\nSprawl'] = (n_v, e, compute_betti_graph(e, n_v))

n_v, e = build_polycentric()
networks['Poly-\ncentric'] = (n_v, e, compute_betti_graph(e, n_v))

# Print results
print("=" * 55)
print(f"{'Urban Form':<20} {'V':>5} {'E':>5} {'beta_0':>7} {'beta_1':>7}")
print("=" * 55)
for name, (n_v, edges, (b0, b1)) in networks.items():
    clean_name = name.replace('\n', ' ')
    print(f"{clean_name:<20} {n_v:>5} {len(edges):>5} {b0:>7} {b1:>7}")
print("=" * 55)

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

# Betti number comparison
ax = axes[0]
names = [n.replace('\n', '\n') for n in networks.keys()]
b0_vals = [networks[n][2][0] for n in networks]
b1_vals = [networks[n][2][1] for n in networks]
x_pos = np.arange(len(names))
width = 0.35

bars1 = ax.bar(x_pos - width/2, b0_vals, width, color='#10b981', alpha=0.8, label='beta_0 (components)')
bars2 = ax.bar(x_pos + width/2, b1_vals, width, color='#06b6d4', alpha=0.8, label='beta_1 (loops)')

ax.set_xticks(x_pos)
ax.set_xticklabels([n.replace('\n', '\n') for n in networks.keys()], fontsize=9, color='white')
ax.set_ylabel('Betti Number', fontsize=12, color='white')
ax.set_title('Topological Signatures of Urban Forms', 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, axis='y')

# Add value labels
for bar in bars1:
    ax.text(bar.get_x() + bar.get_width()/2, bar.get_height() + 0.3,
            str(int(bar.get_height())), ha='center', color='#10b981', fontsize=10)
for bar in bars2:
    ax.text(bar.get_x() + bar.get_width()/2, bar.get_height() + 0.3,
            str(int(bar.get_height())), ha='center', color='#06b6d4', fontsize=10)

# Scatter: beta_0 vs beta_1
ax = axes[1]
colors_scatter = ['#10b981', '#f59e0b', '#06b6d4', '#ef4444', '#8b5cf6']
for idx, (name, (n_v, edges, (b0, b1))) in enumerate(networks.items()):
    clean = name.replace('\n', ' ')
    ax.scatter(b0, b1, color=colors_scatter[idx], s=200, zorder=5,
               edgecolors='white', linewidth=1.5)
    ax.annotate(clean, (b0, b1), textcoords='offset points',
                xytext=(10, 5), fontsize=9, color=colors_scatter[idx])

ax.set_xlabel('beta_0 (connected components)', fontsize=12, color='white')
ax.set_ylabel('beta_1 (independent loops)', fontsize=12, color='white')
ax.set_title('Topological Phase Space of City Forms', fontsize=14, color='white', fontweight='bold')
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: urban morphology Betti numbers")
print("\nInterpretation:")
print("- Grid: beta_1 >> 1 (many alternative routes)")
print("- Sprawl: beta_0 >> 1 (fragmented), beta_1 low (no route choice)")
print("- Polycentric: moderate beta_1 (cores provide loops)")

Click Run to execute the Python code

Code will be executed with Python 3 on the server

7. The Euler Characteristic

The Euler characteristic provides a single topological invariant that combines all Betti numbers:

$$\chi = \sum_{k=0}^n (-1)^k \beta_k = \beta_0 - \beta_1 + \beta_2 - \cdots$$

For a graph, $\chi = \beta_0 - \beta_1 = V - E$. For a planar graph with faces, $\chi = V - E + F = 2$ (Euler's formula for a sphere). The Euler characteristic is computable directly from the simplicial structure without computing homology:

$$\chi = \sum_{k=0}^n (-1)^k |\mathcal{K}_k|$$

where $|\mathcal{K}_k|$ is the number of $k$-simplices. This topological invariant is preserved under continuous deformations of the network, making it robust to small perturbations in the urban layout.

Key Takeaway

Simplicial homology provides rigorous, computable invariants for urban network topology. The Betti numbers $\beta_0$ and $\beta_1$ capture the most urbanistically relevant features: connectivity and route redundancy. Different city morphologies occupy distinct regions in the $(\beta_0, \beta_1)$ plane, providing a topological fingerprint for urban form.

← Part 15 Overview Persistent Homology →