Quantum Game Theory for Urban Coordination

Classical game theory models urban coordination failures—developers who would benefit from cooperation end up in a Prisoner's Dilemma. Quantum game theory shows that “entangled” strategies (binding agreements, shared infrastructure) can escape this trap, achieving outcomes that Pareto-dominate the classical Nash equilibrium.

1. Classical Prisoner's Dilemma

Consider two neighbouring landowners who each choose to Develop (D) or Conserve (C). The payoff matrix reflects the urban coordination problem:

	Player B: C	Player B: D
Player A: C	(3, 3)	(0, 5)
Player A: D	(5, 0)	(1, 1)

The classical Nash equilibrium is (D, D) with payoffs (1, 1)—both develop, degrading the shared environment. Yet mutual conservation (C, C) yields (3, 3). This is the dilemma: individual rationality leads to collective suboptimality.

In urban terms: each developer profits most by building while the neighbour preserves green space, but when both build, congestion and environmental degradation reduce everyone's returns.

2. The Eisert-Wilkens-Lewenstein Protocol

Eisert, Wilkens, and Lewenstein (1999) proposed a quantum version of the game. The two-player system starts in state $|CC\rangle$. An entangling gate $\hat{J}(\gamma)$ correlates the players before they choose their strategies:

$$\hat{J}(\gamma) = \exp\!\left(\frac{i\gamma}{2}\,\hat{D}\otimes\hat{D}\right)$$

where $\hat{D} = \begin{pmatrix}0 & 1\\1 & 0\end{pmatrix}$ is the “defect” operator (Pauli X). The parameter $\gamma \in [0, \pi/2]$ controls the degree of entanglement:$\gamma = 0$ is the classical game, $\gamma = \pi/2$ is maximal entanglement.

Each player applies a unitary strategy operator:

$$\hat{U}(\theta, \phi) = \begin{pmatrix} e^{i\phi}\cos(\theta/2) & \sin(\theta/2) \\ -\sin(\theta/2) & e^{-i\phi}\cos(\theta/2) \end{pmatrix}$$

The final state is:

$$|\psi_f\rangle = \hat{J}^{\dagger}(\gamma)\,\bigl(\hat{U}_A \otimes \hat{U}_B\bigr)\,\hat{J}(\gamma)\,|CC\rangle$$

The expected payoff for player A is computed by measuring the final state in the computational basis and weighting by the classical payoff matrix.

3. Classical vs. Quantum Strategies

The classical strategies are embedded as special cases:

Cooperate (C): $\hat{U}(0, 0) = \hat{I}$ (identity—do nothing)
Defect (D): $\hat{U}(\pi, 0)$ (bit flip)
Quantum (Q): $\hat{U}(0, \pi/2)$ (phase flip—uniquely quantum)

The key result: at maximal entanglement ($\gamma = \pi/2$), the strategy pair $(Q, Q)$ is a Nash equilibrium with payoff (3, 3) —the same as mutual cooperation. Moreover, $Q$ is not vulnerable to classical defection:

$$\text{Payoff}(Q, D) = \text{Payoff}(Q, C) = 3 \quad (\text{at } \gamma = \pi/2)$$

The quantum Nash equilibrium Pareto-dominates the classical one: both players get 3 instead of 1. Entanglement resolves the dilemma.

4. Urban Interpretation: Entanglement as Binding Agreements

The quantum formalism is a mathematical metaphor for correlated strategy spaces:

Entanglement ($\gamma > 0$) represents binding agreements, shared infrastructure bonds, or joint ventures that correlate the players' actions beyond what classical mixed strategies can achieve.
Quantum strategies ($\phi \neq 0$) represent conditional commitments: “I will conserve if and only if you conserve, enforced by a third-party mechanism.”
Maximal entanglement corresponds to perfectly enforceable contracts—the strongest institutional framework.
Partial entanglement ($0 < \gamma < \pi/2$) models imperfect enforcement or partial trust between stakeholders.

Planning Implication

The quantum game framework quantifies how much “institutional entanglement” is needed to escape urban coordination failures. The transition from classical to quantum Nash equilibrium occurs at a critical entanglement level, suggesting that weak governance structures may not suffice—there is a threshold below which defection remains dominant.

5. Computing the Quantum Payoff Landscape

The code below implements the EWL protocol. We compute payoffs across the strategy space and find the quantum Nash equilibrium.

Quantum Prisoner's Dilemma for Urban Development Coordination

Python

script.py147 lines

import numpy as np
import matplotlib.pyplot as plt

# --- Payoff matrix (Prisoner's Dilemma) ---
# Rows: A's action, Cols: B's action
# Actions: 0 = C (cooperate/conserve), 1 = D (defect/develop)
payoff_A = np.array([[3, 0],
                      [5, 1]])
payoff_B = np.array([[3, 5],
                      [0, 1]])

# --- Quantum game machinery ---
def U(theta, phi):
    """Single-player strategy unitary."""
    return np.array([
        [np.exp(1j*phi)*np.cos(theta/2), np.sin(theta/2)],
        [-np.sin(theta/2), np.exp(-1j*phi)*np.cos(theta/2)]
    ])

def J(gamma):
    """Entangling gate J(gamma) = exp(i*gamma/2 * D x D)."""
    # D = Pauli X = [[0,1],[1,0]]
    # D x D = [[0,0,0,1],[0,0,1,0],[0,1,0,0],[1,0,0,0]]
    DxD = np.array([[0,0,0,1],[0,0,1,0],[0,1,0,0],[1,0,0,0]], dtype=complex)
    return np.cos(gamma/2)*np.eye(4) + 1j*np.sin(gamma/2)*DxD

def quantum_payoff(theta_A, phi_A, theta_B, phi_B, gamma):
    """Compute expected payoffs for both players."""
    # Initial state |CC> = |00>
    psi0 = np.array([1, 0, 0, 0], dtype=complex)

# Apply J
    Jg = J(gamma)
    Jdag = Jg.conj().T

# Apply U_A x U_B
    UA = U(theta_A, phi_A)
    UB = U(theta_B, phi_B)
    UAxUB = np.kron(UA, UB)

# Final state: J^dag (UA x UB) J |CC>
    psi_f = Jdag @ UAxUB @ Jg @ psi0

# Probabilities for each outcome |ij>
    probs = np.abs(psi_f)**2  # [P(CC), P(CD), P(DC), P(DD)]

# Expected payoffs
    pA = probs[0]*payoff_A[0,0] + probs[1]*payoff_A[0,1] + \
         probs[2]*payoff_A[1,0] + probs[3]*payoff_A[1,1]
    pB = probs[0]*payoff_B[0,0] + probs[1]*payoff_B[0,1] + \
         probs[2]*payoff_B[1,0] + probs[3]*payoff_B[1,1]
    return pA.real, pB.real

# --- Named strategies ---
C = (0, 0)        # Cooperate: I
D = (np.pi, 0)    # Defect: X (bit flip)
Q = (0, np.pi/2)  # Quantum: phase flip

# --- Scan over gamma: payoffs for key strategy pairs ---
gammas = np.linspace(0, np.pi/2, 50)
pairs = {
    '(C,C)': (C, C),
    '(D,D)': (D, D),
    '(Q,Q)': (Q, Q),
    '(Q,D)': (Q, D),
    '(D,Q)': (D, Q),
}

payoffs_scan = {name: [] for name in pairs}
for g in gammas:
    for name, (sA, sB) in pairs.items():
        pA, pB = quantum_payoff(sA[0], sA[1], sB[0], sB[1], g)
        payoffs_scan[name].append(pA)

# --- Scan payoff landscape (Player A) for fixed gamma = pi/2 ---
n_grid = 40
thetas = np.linspace(0, np.pi, n_grid)
phis = np.linspace(0, np.pi/2, n_grid)
gamma_max = np.pi / 2

# Fix B at Q strategy, scan A
pA_grid = np.zeros((n_grid, n_grid))
for i, th in enumerate(thetas):
    for j, ph in enumerate(phis):
        pA_grid[i, j], _ = quantum_payoff(th, ph, Q[0], Q[1], gamma_max)

# --- Visualisation ---
fig, axes = plt.subplots(1, 3, figsize=(15, 5))

# (a) Payoff vs entanglement
ax = axes[0]
colors_map = {'(C,C)': '#059669', '(D,D)': '#dc2626', '(Q,Q)': '#0d9488',
              '(Q,D)': '#6366f1', '(D,Q)': '#f59e0b'}
for name, vals in payoffs_scan.items():
    ax.plot(gammas*2/np.pi, vals, linewidth=2, label=name, color=colors_map[name])
ax.set_xlabel('Entanglement (gamma / (pi/2))')
ax.set_ylabel('Player A payoff')
ax.set_title('Payoff vs Entanglement')
ax.legend(fontsize=8)
ax.axhline(3, color='gray', linestyle=':', alpha=0.3)
ax.axhline(1, color='gray', linestyle=':', alpha=0.3)

# (b) Strategy landscape at max entanglement
ax = axes[1]
TH, PH = np.meshgrid(thetas/np.pi, phis/(np.pi/2), indexing='ij')
im = ax.contourf(TH, PH, pA_grid, levels=20, cmap='YlGn')
ax.plot(Q[0]/np.pi, Q[1]/(np.pi/2), 'r*', markersize=15, label='Q strategy')
ax.plot(D[0]/np.pi, D[1]/(np.pi/2), 'ko', markersize=10, label='D strategy')
ax.plot(C[0]/np.pi, C[1]/(np.pi/2), 'ws', markersize=10, label='C strategy')
ax.set_xlabel('theta / pi')
ax.set_ylabel('phi / (pi/2)')
ax.set_title('A payoff (B plays Q, gamma=pi/2)')
ax.legend(fontsize=8)
plt.colorbar(im, ax=ax)

# (c) Nash equilibrium comparison
ax = axes[2]
strategies = ['Classical\n(D,D)', 'Quantum\n(Q,Q)']
payoffs_comparison = [
    quantum_payoff(D[0], D[1], D[0], D[1], 0),       # classical
    quantum_payoff(Q[0], Q[1], Q[0], Q[1], np.pi/2),  # quantum
]
x_pos = np.arange(len(strategies))
width = 0.35
ax.bar(x_pos - width/2, [p[0] for p in payoffs_comparison], width,
       label='Player A', color='teal', alpha=0.8)
ax.bar(x_pos + width/2, [p[1] for p in payoffs_comparison], width,
       label='Player B', color='#059669', alpha=0.8)
ax.set_xticks(x_pos)
ax.set_xticklabels(strategies)
ax.set_ylabel('Payoff')
ax.set_title('Nash Equilibrium Payoffs')
ax.legend()
ax.set_ylim(0, 4)

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

# Print key results
print("=== Quantum Game Theory Results ===")
print(f"Classical NE (D,D) at gamma=0:    A={quantum_payoff(*D,*D,0)[0]:.2f}, B={quantum_payoff(*D,*D,0)[1]:.2f}")
print(f"Quantum NE (Q,Q) at gamma=pi/2:   A={quantum_payoff(*Q,*Q,np.pi/2)[0]:.2f}, B={quantum_payoff(*Q,*Q,np.pi/2)[1]:.2f}")
print(f"Defect vs Q at gamma=pi/2:         A={quantum_payoff(*D,*Q,np.pi/2)[0]:.2f}")
print(f"Q vs Defect at gamma=pi/2:         A={quantum_payoff(*Q,*D,np.pi/2)[0]:.2f}")
print(f"\nQuantum NE Pareto-dominates classical: {quantum_payoff(*Q,*Q,np.pi/2)[0] > quantum_payoff(*D,*D,0)[0]}")

Click Run to execute the Python code

Code will be executed with Python 3 on the server

6. Formal Result: Quantum Nash Equilibrium

At maximal entanglement $\gamma = \pi/2$, one can show analytically that $(Q, Q)$ is a Nash equilibrium. The proof proceeds by showing that no unilateral deviation improves a player's payoff:

$$\pi_A\bigl(\hat{U}(\theta,\phi),\, Q\bigr) = 3\cos^2(\theta/2) + \sin^2(\theta/2)\bigl[5\sin^2\phi + \cos^2\phi\bigr]$$

For the standard PD payoffs (3, 0, 5, 1), this expression is maximised at $\theta = 0$ (regardless of $\phi$), giving payoff 3. Since $Q = \hat{U}(0, \pi/2)$ is a special case of $\theta = 0$, no deviation from $Q$ improves the payoff.

Key Takeaway

Quantum game theory provides a rigorous framework for understanding how institutional mechanisms (entanglement) can resolve urban coordination failures. The mathematics shows that the improvement is not gradual—there is a phase transition at a critical entanglement level where the quantum equilibrium suddenly becomes available, analogous to a critical mass of institutional capacity enabling cooperative urban governance.

← Fractional Fokker-Planck Part 9: Multi-Scale Methods →