Siemens Quantum Optimization for Smart City Traffic Signal Coordination

The Problem

Traffic signal coordination is a large-scale combinatorial optimization problem that cities have been solving imperfectly for decades. The goal is to allocate green time across intersections such that vehicles progress through arterial corridors without stopping at every light, maximizing network throughput and minimizing aggregate delay.

Classical Adaptive Signal Control Technology (ASCT) systems like SCOOT (Split Cycle Offset Optimisation Technique) and SCATS (Sydney Coordinated Adaptive Traffic System) use hill-climbing heuristics to adjust signal timing in real time. They work well in practice, but operate locally: each intersection or small cluster is optimized with limited awareness of the broader network state. This myopic optimization leaves throughput on the table in dense networks with many interacting intersections.

Siemens’ Sitraffic team, which supplies ASCT hardware and software to cities globally, investigated whether quantum optimization could find better coordinated solutions across larger intersection subnetworks. The research targeted the green wave coordination problem: finding phase offsets across an arterial network that create the longest possible uninterrupted green progressions for the dominant traffic direction.

Intersection Conflict Graph

A traffic signal cycle consists of phases: combinations of movements that can proceed simultaneously without conflict. At a standard four-way intersection, north-south through traffic and east-west through traffic conflict (they cannot both have green simultaneously). Left turns conflict with opposing through movements.

The intersection network can be represented as a conflict graph:

• Nodes: signal phases across all intersections in the network (each intersection contributes 2 to 4 phases)
• Edges: conflict relationships (two phases cannot both be green simultaneously, either within an intersection or due to vehicle progression conflicts between adjacent intersections)
• Weights: traffic demand on each phase (vehicles per hour requiring that movement)

Maximizing throughput subject to no conflicting phases being simultaneously green is a maximum-weight independent set problem on this graph, a canonical NP-hard problem with a natural QUBO formulation.

QUBO Formulation

Define binary variable x[i] = 1 if phase i is assigned green in the current cycle, 0 if red. The objective maximizes weighted throughput minus penalties for conflicts and minimum green time violations.

from qiskit_optimization import QuadraticProgram
from qiskit_optimization.algorithms import MinimumEigenOptimizer
from qiskit_algorithms import QAOA
from qiskit_algorithms.optimizers import COBYLA
from qiskit.primitives import Sampler
import numpy as np

def build_traffic_qubo(phases, conflicts, demand, min_green_penalty=5.0):
    """
    Build QUBO for traffic signal phase selection.
    
    phases: list of phase IDs
    conflicts: list of (phase_i, phase_j) conflict pairs
    demand: dict mapping phase_id -> traffic demand (veh/hr)
    """
    qp = QuadraticProgram("traffic_signal_coordination")
    
    # Binary variable for each phase
    for phase_id in phases:
        qp.binary_var(name=f'x_{phase_id}')
    
    # Objective: maximize sum of demand for active phases
    # (minimize negative demand)
    linear_terms = {f'x_{p}': -demand[p] for p in phases}
    
    # Conflict penalty: penalize any pair of conflicting phases both selected
    quadratic_terms = {}
    for pi, pj in conflicts:
        key = (f'x_{pi}', f'x_{pj}')
        quadratic_terms[key] = min_green_penalty * max(demand[pi], demand[pj])
    
    qp.minimize(linear=linear_terms, quadratic=quadratic_terms)
    
    return qp


# Example: 16-intersection arterial corridor, 4 phases each = 64 binary vars
# Conflict graph derived from VISSIM microsimulation traffic data
qp = build_traffic_qubo(phase_ids, conflict_pairs, demand_dict)

# QAOA with p=3 layers
from qiskit_optimization.converters import QuadraticProgramToQubo
converter = QuadraticProgramToQubo()
qubo = converter.convert(qp)

qaoa = QAOA(
    sampler=Sampler(),
    optimizer=COBYLA(maxiter=300),
    reps=3,          # p=3 QAOA layers
    initial_point=None,
)
optimizer = MinimumEigenOptimizer(qaoa)
result = optimizer.solve(qp)

print(f"Optimal phase selection: {result.x}")
print(f"Throughput score: {-result.fval:.1f} veh/hr")

Phase Offset and Green Wave Encoding

Beyond phase selection within a single cycle, the coordination problem requires setting offsets between adjacent intersections. An offset is the time delay between the start of the green phase at intersection A and the corresponding green phase at intersection B. For a vehicle traveling the corridor at 50 km/h, the optimal offset between signals 300 meters apart is 21.6 seconds.

Offsets were encoded as integer variables discretized to 5-second slots across a 90-second cycle length (18 possible values per intersection pair). The QUBO included quadratic penalty terms for offset combinations that produced conflicting green waves (where vehicles arriving from one direction would hit red at the next intersection while the green wave served the opposite direction).

For the 16-intersection network, this produced a QUBO with approximately 400 binary variables after discretization, within the range of QAOA simulation and compatible with IBM Eagle’s 127 qubits after SWAP routing overhead.

Comparison to SCOOT and SCATS

The benchmark simulations used VISSIM traffic microsimulation with calibrated flow data from a mid-sized European city arterial corridor. Three control strategies were compared:

SCOOT baseline: The classical SCOOT system optimized split, cycle, and offset parameters iteratively using a gradient-based hill climber seeded from historical timing plans.

QAOA p=3 (IBM Eagle): QAOA was run with 3 layers of parameterized circuit, optimized using COBYLA. For the 16-intersection network, QAOA p=3 reached solutions within 2% of the SCOOT optimized throughput. At p=1 and p=2, QAOA underperformed SCOOT by 6% and 3% respectively.

D-Wave hybrid (50-intersection simulation): For the larger 50-intersection network (too large for circuit-based QAOA at acceptable depth), the team used D-Wave’s LeapHybridSampler on the QUBO formulation. The hybrid solver found solutions with 8% higher intersection throughput than SCOOT on a simulated 50-intersection grid network.

Method	Network size	Throughput vs SCOOT	Solve time
SCOOT (baseline)	16 intersections	—	2 s (real-time)
QAOA p=1	16 intersections	-6%	45 s
QAOA p=2	16 intersections	-3%	90 s
QAOA p=3	16 intersections	+0% (matched)	180 s
D-Wave hybrid	50 intersections	+8%	22 s
SCATS (reference)	50 intersections	-3% vs SCOOT	—

The 8% throughput improvement from D-Wave hybrid on the 50-intersection network is significant in urban traffic terms: it corresponds to approximately 12% reduction in average intersection delay, which meaningfully improves journey times and reduces vehicle emissions from idling.

Why Classical Systems Leave Throughput Available

SCOOT and SCATS optimize locally: a subnetwork coordinator adjusts timing based on vehicle queue detectors at each intersection. The coordination across 50 intersections is hierarchical and approximate. The quantum QUBO formulation treats all 50 intersections simultaneously, finding offset combinations that create coordinated green waves the hierarchical heuristic misses.

The improvement is not universal. On sparse networks with low inter-intersection interaction, SCOOT and SCATS are near-optimal, and the quantum formulation shows no advantage. The 8% gain emerges specifically in dense grids where green waves in the east-west direction interact with north-south progressions in non-obvious ways.

Practical Deployment Considerations

Siemens evaluated the quantum approach against four practical criteria:

Solve latency. SCOOT operates on 5-second update cycles. The 22-second D-Wave hybrid solve time is too slow for real-time control but acceptable for a strategic planning layer that generates timing plans every few minutes, which are then executed by conventional controllers.

Hardware availability. Cloud access to D-Wave via Leap is reliable for planning workloads. IBM Eagle access for QAOA is more variable at useful queue times.

Integration with existing infrastructure. The quantum optimizer was prototyped as a drop-in replacement for the timing plan optimizer component in Sitraffic Scala, Siemens’ ASCT software. The interface required no changes to field controller hardware.

Scalability. A city-scale deployment (500+ intersections) requires further decomposition techniques. Siemens is investigating hierarchical decomposition where quantum optimization handles intersection clusters and classical coordination handles inter-cluster offsets.