Vodafone: Quantum Optimisation for 5G Network Slicing

The Challenge

5G network slicing allows a single physical mobile network to be partitioned into multiple isolated virtual networks, each with distinct performance characteristics. An enhanced mobile broadband slice optimises for high throughput. An ultra-reliable low-latency slice prioritises sub-millisecond response times for industrial automation. A massive machine-type communications slice supports dense IoT deployments with energy-efficient intermittent transmissions.

Managing these slices dynamically is a hard combinatorial problem. As traffic patterns shift across Vodafone’s network, available radio and compute resources at each base station must be reallocated across active slices in near real time. Each reallocation must respect bandwidth constraints per cell, latency service-level agreements per slice type, and load-balancing requirements across adjacent cells. The number of possible assignments grows exponentially with network size: a 30-node network with three slice types and five resource levels per node has a search space of $5^{90}$.

Classical network management systems use greedy heuristics or linear programming relaxations, which execute quickly but leave measurable utilisation headroom on the table, particularly during demand surges when multiple slice types compete for the same resources simultaneously. Vodafone’s network engineering team explored QAOA as a method to find higher-quality allocations without unacceptable latency overhead.

The Quantum Approach

The network slicing problem was formulated as a QUBO over binary assignment variables $x_{n,s,r} \in \{0,1\}$, where $n$ indexes base station nodes, $s$ indexes slice types, and $r$ indexes discrete resource levels. The objective minimised total unmet demand weighted by slice priority, while quadratic penalty terms enforced per-node resource budget constraints and per-slice latency requirements.

For tractability on 27-qubit IBM Quantum hardware, the full 30-node problem was decomposed into overlapping 10-node subproblems solved sequentially, with solutions aggregated by a classical coordination layer.

import numpy as np
from qiskit_optimization import QuadraticProgram
from qiskit_optimization.converters import QuadraticProgramToQubo
from qiskit_algorithms import QAOA
from qiskit_algorithms.optimizers import SPSA
from qiskit.primitives import Sampler

# Network parameters for a 10-node subproblem
N_NODES = 10
N_SLICES = 3       # eMBB, URLLC, mMTC
N_LEVELS = 3       # resource allocation levels: low, medium, high

# Demand matrix: shape (N_NODES, N_SLICES) - normalised unmet demand
demand = np.array([
    [0.8, 0.3, 0.5],
    [0.2, 0.9, 0.4],
    [0.6, 0.1, 0.7],
    [0.4, 0.6, 0.2],
    [0.9, 0.4, 0.3],
    [0.3, 0.7, 0.8],
    [0.5, 0.2, 0.6],
    [0.7, 0.5, 0.1],
    [0.1, 0.8, 0.9],
    [0.6, 0.3, 0.4],
])

# Slice priority weights: URLLC highest, eMBB medium, mMTC lowest
priority = np.array([0.6, 1.0, 0.3])

# Resource capacity per node (normalised)
capacity = np.ones(N_NODES)

qp = QuadraticProgram("vodafone_slicing")

# Binary variables: x_{n}_{s}_{r} = 1 if node n serves slice s at level r
for n in range(N_NODES):
    for s in range(N_SLICES):
        for r in range(N_LEVELS):
            qp.binary_var(name=f"x_{n}_{s}_{r}")

# Objective: maximise weighted demand satisfaction
linear = {}
for n in range(N_NODES):
    for s in range(N_SLICES):
        for r in range(N_LEVELS):
            # Higher resource level r satisfies more demand
            satisfaction = demand[n, s] * priority[s] * (r + 1) / N_LEVELS
            linear[f"x_{n}_{s}_{r}"] = -satisfaction  # minimise negative = maximise

qp.minimize(linear=linear)

# Constraint: total resource usage per node <= capacity
resource_costs = [0.2, 0.5, 1.0]  # low, medium, high levels
for n in range(N_NODES):
    coeffs = {}
    for s in range(N_SLICES):
        for r in range(N_LEVELS):
            coeffs[f"x_{n}_{s}_{r}"] = resource_costs[r]
    qp.linear_constraint(linear=coeffs, sense="<=", rhs=capacity[n], name=f"cap_{n}")

converter = QuadraticProgramToQubo()
qubo = converter.convert(qp)

sampler = Sampler()
optimizer = SPSA(maxiter=200)
qaoa = QAOA(sampler=sampler, optimizer=optimizer, reps=2)

from qiskit_optimization.algorithms import MinimumEigenOptimizer
result = MinimumEigenOptimizer(qaoa).solve(qubo)
print(f"Allocation objective: {result.fval:.4f}")

The quantum solution was compared against a classical greedy baseline that allocated resources to slices in priority order until per-node budgets were exhausted.

Results and Implications

Across 50 simulated demand scenarios on the 30-node network, QAOA-based slice allocation achieved 18% higher average network slice utilisation than the classical greedy algorithm, measured as the fraction of total demand satisfied weighted by slice priority. The improvement was most pronounced during demand surges, where the greedy algorithm’s sequential allocation strategy starved lower-priority slices even when resources could have been shared more efficiently.

End-to-end optimisation latency for the 30-node decomposed problem was approximately 2.3 seconds using IBM Quantum cloud access, compared to 0.08 seconds for the greedy algorithm. While this latency gap currently precludes real-time deployment, Vodafone’s engineering team identified a hybrid architecture where quantum optimisation runs ahead of demand peaks on predicted traffic patterns, with the classical greedy algorithm handling unexpected demand spikes between quantum updates.

The study reinforced that 5G network management is a structurally attractive quantum application: the problem is combinatorial, the objective function maps naturally to QUBO, and even modest utilisation improvements translate to significant infrastructure cost savings at the scale of a national mobile network. Vodafone plans to extend the study to 100-node networks as quantum hardware scales, targeting integration with their live network management platform within a three to five year horizon.