Bid-Rent Gradient

The Alonso-Muth-Mills monocentric city model derives the spatial structure of land prices from first principles of household utility maximisation. The key result is an exponentially declining rent gradient -- the theoretical backbone of urban land economics.

1. The Monocentric City Model

Consider a city with a single central business district (CBD) at the origin. All employment is at the CBD. A household living at distance $r$ from the CBD earns income $y$ and faces:

Commuting cost $t \cdot r$ (linear in distance, with cost per unit distance $t$)
Housing rent $p(r) \cdot q$ for $q$ units of housing
A composite good $z$ (price normalised to 1)

The household maximises utility $U(q, z)$ subject to the budget constraint:

$$y = p(r) \cdot q + z + t \cdot r$$

In equilibrium, every household achieves the same utility level $\bar{U}$ regardless of location. Those who live farther from the CBD pay lower rent but higher commuting costs; those who live closer pay higher rent but save on commuting.

2. Deriving the Bid-Rent Function

The bid-rent function $p(r)$ is the maximum rent per unit of housing that a household at distance $r$ is willing to pay while achieving utility $\bar{U}$. Define the indirect utility:

$$V(p, y - tr) = \max_{q, z} U(q, z) \quad \text{s.t.} \quad p \cdot q + z = y - tr$$

Setting up the Lagrangian with multiplier $\lambda$:

$$\mathcal{L} = U(q, z) + \lambda\bigl(y - tr - pq - z\bigr)$$

The first-order conditions are:

$$\frac{\partial U}{\partial q} = \lambda p, \qquad \frac{\partial U}{\partial z} = \lambda$$

Dividing these gives the tangency condition:

$$\frac{\partial U / \partial q}{\partial U / \partial z} = p(r)$$

The spatial equilibrium condition requires $dV/dr = 0$. By the envelope theorem:

$$\frac{dV}{dr} = \lambda\!\left(-q\frac{dp}{dr} - t\right) = 0$$

Since $\lambda > 0$, we obtain the Muth condition:

$$\frac{dp}{dr} = -\frac{t}{q^*(r)}$$

This is the fundamental differential equation of urban spatial structure. Rent declines with distance at a rate inversely proportional to housing consumption.

Special Case: Cobb-Douglas Utility

Let $U(q, z) = q^\alpha z^{1-\alpha}$. The optimal housing demand is $q^* = \alpha(y - tr)/p$ and composite good is $z^* = (1-\alpha)(y-tr)$. Substituting into the budget:

$$p(r) = \frac{y - tr - z^*}{q^*} = \frac{\alpha(y - tr)}{\alpha(y - tr)/p} \cdot \frac{1}{1} $$

Using the equal-utility condition with the indirect utility $V = C \cdot p^{-\alpha}(y-tr)$ set to $\bar{U}$, we solve for the bid-rent:

$$p(r) = \left(\frac{C(y - tr)}{\bar{U}}\right)^{1/\alpha}$$

For small $tr/y$, using $\ln(1 - x) \approx -x$, this gives the exponential approximation:

$$p(r) \approx p(0) \, e^{-tr / (\alpha y)}$$

3. Multiple Income Groups and Land-Use Zoning

When multiple income groups compete for land, each group has its own bid-rent curve. At each distance $r$, the group willing to pay the highest rent occupies that location. This produces concentric land-use rings:

$$\text{Land at } r \text{ goes to group } k^* = \arg\max_k \; p_k(r)$$

For three land uses -- commercial, residential, and agricultural -- the bid-rent curves satisfy $|dp_{\text{comm}}/dr| > |dp_{\text{res}}/dr| > |dp_{\text{agr}}/dr|$because commercial activities value CBD access more intensely. This produces the classic von Thunen rings: commercial core, residential ring, agricultural fringe.

Among residential groups, higher-income households have steeper bid-rent curves if the income elasticity of housing demand exceeds the income elasticity of commuting cost. When the opposite holds, wealthier households suburbanise -- the pattern observed in most American cities.

4. Python: Bid-Rent Curves and Land-Use Zoning

We plot bid-rent curves for three income groups under Cobb-Douglas preferences and show how land-use zones emerge from the envelope of the curves.

Bid-Rent Curves and Land-Use Zoning

Python

script.py82 lines

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.patches import Patch

# --- Parameters ---
alpha = 0.3   # housing share in Cobb-Douglas
t = 1.0       # commuting cost per unit distance

# Income groups
groups = {
    'Low income':  {'y': 40, 'color': '#10b981', 'ls': '-'},
    'Mid income':  {'y': 70, 'color': '#06b6d4', 'ls': '--'},
    'High income': {'y': 120, 'color': '#f59e0b', 'ls': '-.'},
}

r = np.linspace(0, 35, 500)

fig, axes = plt.subplots(1, 2, figsize=(14, 5.5))

# --- Left panel: Bid-rent curves ---
ax = axes[0]
curves = {}
for name, g in groups.items():
    y = g['y']
    # p(r) = C * (y - t*r)^(1/alpha) for r < y/t, with normalisation
    net_income = np.maximum(y - t * r, 0.01)
    p0 = (y)**( 1/alpha)
    p = (net_income)**(1/alpha) / p0 * y * 0.8  # normalised
    p[net_income <= 0.01] = 0
    curves[name] = p
    ax.plot(r, p, color=g['color'], linestyle=g['ls'], linewidth=2.5, label=name)

ax.set_xlabel('Distance from CBD (r)', fontsize=12, color='white')
ax.set_ylabel('Bid-Rent p(r)', fontsize=12, color='white')
ax.set_title('Bid-Rent Curves by Income Group', fontsize=13, color='white')
ax.legend(fontsize=11, facecolor='#1e293b', edgecolor='#10b981', labelcolor='white')
ax.tick_params(colors='white')
ax.grid(True, alpha=0.3)
ax.set_ylim(0, None)

# --- Right panel: Land-use zoning (who wins at each r) ---
ax2 = axes[1]
names = list(groups.keys())
colors_map = [groups[n]['color'] for n in names]
curve_array = np.array([curves[n] for n in names])  # shape (3, len(r))
winner = np.argmax(curve_array, axis=0)
envelope = np.max(curve_array, axis=0)

# Plot envelope
ax2.plot(r, envelope, 'w-', linewidth=2, label='Market rent (envelope)')

# Shade zones
prev_winner = winner[0]
start_idx = 0
for i in range(1, len(r)):
    if winner[i] != prev_winner or i == len(r) - 1:
        ax2.axvspan(r[start_idx], r[i], alpha=0.25, color=colors_map[prev_winner])
        start_idx = i
        prev_winner = winner[i]

# Add individual curves faintly
for name, g in groups.items():
    ax2.plot(r, curves[name], color=g['color'], linewidth=1, alpha=0.4)

legend_elements = [Patch(facecolor=colors_map[i], alpha=0.4, label=names[i]) for i in range(3)]
legend_elements.append(plt.Line2D([0], [0], color='white', linewidth=2, label='Market rent'))
ax2.legend(handles=legend_elements, fontsize=10, facecolor='#1e293b', edgecolor='#10b981', labelcolor='white')

ax2.set_xlabel('Distance from CBD (r)', fontsize=12, color='white')
ax2.set_ylabel('Rent p(r)', fontsize=12, color='white')
ax2.set_title('Emergent Land-Use Zoning', fontsize=13, color='white')
ax2.tick_params(colors='white')
ax2.grid(True, alpha=0.3)
ax2.set_ylim(0, None)

fig.patch.set_facecolor('#0f172a')
for ax in axes:
    ax.set_facecolor('#0f172a')
plt.tight_layout()
plt.savefig('output.png', dpi=130, bbox_inches='tight', facecolor='#0f172a')
plt.show()
print("Bid-rent curves computed successfully.")

Click Run to execute the Python code

Code will be executed with Python 3 on the server

5. Monocentric City Equilibrium

In the closed-city version of the model, the total population $N$ is fixed. The city boundary $\bar{r}$ is determined by the condition that bid-rent equals the agricultural rent $p_a$:

$$p(\bar{r}) = p_a$$

The population constraint in a circular city (2D) is:

$$N = \int_0^{\bar{r}} \frac{2\pi r}{q^*(r)} \, dr$$

where $q^*(r)$ is the equilibrium housing consumption at $r$, and $2\pi r / q^*(r)$ is the population density. These two conditions -- boundary rent and population -- jointly determine $\bar{r}$ and the equilibrium utility $\bar{U}$.

Comparative Statics

Key predictions of the monocentric model:

$\partial \bar{r} / \partial N > 0$: larger population means larger city
$\partial \bar{r} / \partial t < 0$: higher commuting cost means more compact city
$\partial p(0) / \partial N > 0$: more people raise central land prices
$\partial \bar{U} / \partial N < 0$: in a closed city, more people means lower welfare

Monocentric City: Rent, Housing, and Density Profiles

Python

script.py69 lines

import numpy as np
import matplotlib.pyplot as plt

# Monocentric city: density and rent profiles
alpha = 0.3
t = 1.0
y = 60
p_a = 2.0  # agricultural rent

r = np.linspace(0.01, 40, 500)
net = np.maximum(y - t * r, 0.01)

# Bid-rent (Cobb-Douglas)
p0_val = (y)**(1/alpha)
p = (net)**(1/alpha) / p0_val * y * 0.8
p[net <= 0.01] = 0

# City boundary
r_bar_idx = np.argmin(np.abs(p - p_a))
r_bar = r[r_bar_idx]

# Housing consumption: q*(r) = alpha * net / p(r)
q_star = np.where(p > 0.01, alpha * net / p, np.inf)

# Population density: 2*pi*r / q*(r)
density = np.where(q_star < 1e6, 2 * np.pi * r / q_star, 0)

fig, axes = plt.subplots(1, 3, figsize=(16, 4.5))

# Rent profile
ax = axes[0]
mask = r <= r_bar + 2
ax.plot(r[mask], p[mask], color='#10b981', linewidth=2.5)
ax.axhline(y=p_a, color='#f59e0b', linestyle='--', linewidth=1.5, label=f'$p_a = {p_a}$')
ax.axvline(x=r_bar, color='#ef4444', linestyle=':', linewidth=1.5, label=f'$\\bar{{r}} = {r_bar:.1f}$')
ax.set_xlabel('Distance r', color='white')
ax.set_ylabel('Rent p(r)', color='white')
ax.set_title('Rent Gradient', fontsize=12, color='white')
ax.legend(fontsize=10, facecolor='#1e293b', edgecolor='#10b981', labelcolor='white')

# Housing consumption
ax = axes[1]
ax.plot(r[mask], q_star[mask], color='#06b6d4', linewidth=2.5)
ax.axvline(x=r_bar, color='#ef4444', linestyle=':', linewidth=1.5)
ax.set_xlabel('Distance r', color='white')
ax.set_ylabel('Housing q*(r)', color='white')
ax.set_title('Housing Consumption', fontsize=12, color='white')
ax.set_ylim(0, np.percentile(q_star[mask & (q_star < 1e6)], 95) * 1.5)

# Population density
ax = axes[2]
ax.plot(r[mask], density[mask], color='#f59e0b', linewidth=2.5)
ax.axvline(x=r_bar, color='#ef4444', linestyle=':', linewidth=1.5)
ax.set_xlabel('Distance r', color='white')
ax.set_ylabel('Density n(r)', color='white')
ax.set_title('Population Density', fontsize=12, color='white')

for ax in axes:
    ax.tick_params(colors='white')
    ax.grid(True, alpha=0.3)
    ax.set_facecolor('#0f172a')

fig.patch.set_facecolor('#0f172a')
plt.tight_layout()
plt.savefig('output.png', dpi=130, bbox_inches='tight', facecolor='#0f172a')
plt.show()
print(f"City boundary: r_bar = {r_bar:.1f}")
print(f"Central rent: p(0) = {p[0]:.2f}")
print(f"Central density: n(0) = {density[1]:.2f}")

Click Run to execute the Python code

Code will be executed with Python 3 on the server

← Schelling Segregation Social Force Model →