A cellular base station has to decide, every few milliseconds, which users attach to which radio head or subcarrier and how much power each one gets. It has to finish before the radio channel changes, a window called the channel coherence time. A proposed answer is to hand this decision to a variational quantum circuit, a small quantum program whose gate angles are trained like neural-network weights. These circuits have matched classical networks with roughly a tenth of the parameters. A quantum processor, though, runs on a second clock: its qubits lose their quantum state within their own coherence times. That loss, called decoherence, shrinks the signal the circuit produces. A weaker signal needs more repeated measurements to read reliably, and each repetition costs wall-clock time against the radio deadline. Prior work has looked at these clocks one at a time. The radio-side literature removes solver latency with classical tricks. The quantum-RL literature reports parameter savings on noiseless simulators. One hardware study measured a 3,700 ms cloud round trip against a 20 ms control loop. No one has asked whether any operating point exists where both clocks are satisfied at once.
This note proposes to derive and measure that feasibility region for a joint discrete–continuous allocation problem. The quantum circuit makes only the discrete assignment. An already-fast classical unfolded solver handles the continuous power, so any benefit or harm can be attributed cleanly. The result is a falsifiable map. It shows, for a given qubit noise level and dispatch latency, the circuit depths and measurement budgets at which a quantum assignment head is both on time and competitive. The decisive comparison is a classical head with the same number of parameters, which the existing quantum-RL benchmarks never ran.
Core Claim
Decoherence and real-time latency are not separate engineering nuisances for quantum policies. They are coupled through the number of measurement shots, the repeated circuit runs averaged to estimate one output.
Under approximately uniform (depolarizing) noise with per-layer survival probability $q$, a depth-$L$ circuit's measured expectation values shrink by a factor of about $q^L$. A policy that picks the best of several assignments must tell apart output means separated by an ideal gap $\Delta$. A Hoeffding argument for averages of $\pm 1$ measurement outcomes then requires a shot count of order
$$N(L) \approx \frac{8\log(2/\delta)}{q^{2L}\,\Delta(L)^2},$$
where $\delta$ is the allowed probability of picking the wrong assignment. The decision is on time only if
$$t_{\text{dispatch}} + N(L)\,\big(L\,t_{\text{layer}} + t_{\text{readout}}\big) \le T_c .$$
Here $t_{\text{dispatch}}$ is the fixed cost of sending the job to the processor, $t_{\text{layer}}$ and $t_{\text{readout}}$ are per-layer gate time and per-shot measurement time, and $T_c$ is the channel coherence time.
Deeper circuits may widen $\Delta$ by representing the decision better. They also shrink $q^{L}$ exponentially and lengthen each shot. Feasible depth is therefore bounded on both sides, and the region can be empty.
A second, mechanistic prediction follows from the SOFTMAX-PQC design of Parametrized Quantum Policies for Reinforcement Learning. That paper maps circuit outputs through a softmax with a trainable inverse temperature $\lambda$, and showed this beats sampling raw measurement probabilities. Uniform contraction by $q^L$ is mathematically equivalent to dividing $\lambda$ by $q^L$. A trainable $\lambda$ should therefore absorb depolarizing noise almost for free in expected-value terms, but only by amplifying shot noise. It should not be able to absorb non-uniform noise such as amplitude damping (the $T_1$ process, which biases qubits toward their ground state), because that noise distorts which assignment ranks first rather than just scaling outputs.
If both predictions hold, they explain why noiseless parameter-efficiency results do not transfer to deadline-bound hardware. They also tell designers exactly which noise channel and which dispatch latency they must beat.
Research Program
The test problem is joint user association and power allocation. It is a mixed-integer nonlinear program: discrete choices coupled to continuous ones through interference. The work of Joint Subcarrier and CPU Time Allocation for Mobile Edge Computing motivates keeping the two coupled: it found that decoupling discrete subcarrier assignment from continuous CPU scheduling roughly halved energy savings.
The policy has two heads.
- Discrete head. It proposes an assignment. It is either a SOFTMAX-PQC with cyclic data re-uploading, in which inputs are re-encoded between trainable layers as in BCQQ, or a classical network with the same parameter count.
- Continuous head. Given the assignment, it is a fixed four-layer unfolded WMMSE graph network taken from Unfolding WMMSE Using Graph Neural Networks for Efficient Power Allocation. That method unrolls an iterative power-control algorithm into a few learned layers and already runs in about 2 ms. We reuse it as the method supplier and do not modify it, so that every difference between conditions comes from the discrete head.
Training follows Variational Quantum Circuits for Deep Reinforcement Learning for stabilization (replay buffers and slowly updated target circuits). It differs in three ways:
- Circuits are simulated as density matrices under calibrated noise channels rather than as ideal state vectors.
- Gradients and rewards are computed from finite-shot estimates, so the agent learns under the same measurement budget it will face at deployment.
- Decisions use sequential shot allocation: the processor keeps sampling only until the leading assignment is separated from the runner-up at confidence $1-\delta$.
The third ingredient is the proposal's constructive contribution. It turns the worst-case $N(L)$ above into an instance-adaptive budget, so easy channel states cost few shots.
Noise channels come in two families. One is uniform depolarizing noise, which tests the absorbed-temperature prediction. The other is amplitude damping plus dephasing. Its $T_1/T_2$ ranges will be drawn from hardware characterizations such as Characterization of loss mechanisms in a fluxonium qubit, which found that the dominant loss mechanism changes across operating frequency. That finding argues for sweeping noise structure, not just noise strength.
Dispatch latency is swept as a free parameter. The sweep runs from near-zero (a co-located processor) to the roughly 3,700 ms cloud round trip measured in First Experience with Real-Time Control Using Simulated VQC-Based Quantum Policies. That study ran an 8-qubit policy on physical cart-pole hardware: about 5 ms in local simulation, far over deadline on a cloud processor. It motivates the latency axis but modeled no noise and no allocation problem.
Two pieces of related work are deliberately not reused. The open-system control methods in QMaxCal penalize control trajectories that drift into lossy channels using a measurement-record divergence. The methods in Scaleable Quantum Control via Physics Constrained Reinforcement Learning cap solver steps and smooth control pulses. Both shape physical control pulses, not the outputs of a decision circuit. They constrain our design only in suggesting that noise-aware training should be part of the objective rather than a post-hoc correction. Non-Markovian noise, where the environment has memory, is out of scope and named as a limitation.
Baselines
Naive reference. Each user attaches to the radio head with the strongest received signal, and full iterative WMMSE then allocates power. This uses no learning and sets the floor any learned assignment must clear.
Strongest discrete-search competitor. The imitation-learned branch-and-bound pruner of Scalable Network Adaptation for Cloud-Rans: An Imitation Learning Approach. It trains a classifier (via the DAgger imitation algorithm) to decide which branches of an exact search tree to discard. It reports speedups of over 20x relative to standard branch-and-bound, with objective loss under 0.6% on 10 radio heads and 15 users, and over 14x when trained on smaller networks. It is strongest because it is near-optimal and already handles exactly this coupled discrete–continuous structure. It will be run on the same instances, its training oracle will be given the same offline compute budget used to train the quantum head, and its wall-clock latency will be measured on the same CPU. Beating it means matching its objective within its reported loss while meeting $T_c$ where it does not, or showing it misses deadlines at network sizes where the hybrid head does not.
Relaxation competitor. Unfolded WMMSE run on a relaxed (fractional) association, followed by rounding. The same paper reports sum-rate 83.21 versus 82.94 for iterative WMMSE and about 2 ms versus 16 ms per sample on its power-only benchmark. No reported result was found on Lacuna for this method with discrete association, so we will produce that number ourselves.
Matched-parameter classical head. A classical multilayer network with the same parameter count as the quantum head, trained with the identical reinforcement-learning loop, replay settings, tuning budget, and 100 seeds. Concretely, if a 14-qubit circuit has 437 parameters, the classical head also has about 437. This is the comparison missing from Benchmarking Quantum Reinforcement Learning, which reported 437 quantum parameters matching a 4,611-parameter classical network. It is the baseline the quantum head most needs to beat.
Ablations. These isolate the key ingredients:
- noiseless training evaluated under noise;
- fixed-shot versus sequential-shot decisions;
- frozen versus trainable $\lambda$.
Why not just…?
Why not just use a small classical network with the same parameter count? This is the most serious threat and plausibly works as well. The existing parameter-efficiency evidence, including the 437-versus-4,611 result, the 97.88% reduction in Multi-Agent Quantum Reinforcement Learning using Evolutionary Optimization, and imitation results in Quantum Imitation Learning, compares against larger classical models. None of it compares against equally small ones. Because of this, the proposal does not claim quantum superiority. Its deliverable is the feasibility map, which is informative either way. If the matched classical head ties or wins at every depth even before noise, that is reported as the headline negative result. The two-clock analysis then becomes moot for this problem class.
Why not just relax and round inside unfolded WMMSE? It is fast and needs no quantum hardware. Its weakness is the quality lost when fractional associations are rounded in tightly coupled instances, as the joint-allocation evidence above suggests. The relaxation baseline measures that gap directly. If the gap is under the imitation-pruning loss, the discrete head is unnecessary on these benchmarks, and we will say so.
Why not just run the circuit in classical simulation on the base-station CPU, as the cart-pole study did in 5 ms? That is a classical model. Its feasibility says nothing about quantum hardware, and it becomes exponentially expensive with qubit count. Simulated latency will still be reported as a classical baseline, since it is honestly the deployable option today.
Why not just apply error mitigation? Common mitigation techniques also work by drawing extra shots, so they move cost along the same shot axis our analysis tracks. Where they are tested, they will be charged their shot cost inside the latency budget rather than treated as free.
Proposed Experiments
Joint allocation benchmark. We extend the UWMMSE ad-hoc network setup (Rayleigh fading, path-loss exponent 2.2, 20 transmitter–receiver pairs, tested at 10 and 30 pairs) with a discrete association layer over a few radio heads. We also use the Cloud-RAN radio-head-selection instances from the imitation-learning paper. Metrics are:
- sum-rate or network power relative to an exact branch-and-bound oracle on small instances;
- per-decision wall-clock latency including modeled dispatch and per-shot time;
- the fraction of channel realizations decided within $T_c$;
- deadline-feasible utility, where late decisions are scored with the stale configuration.
Discrete-only sanity check. BeamManagement6G provides a check where published parameter counts exist. Sample complexity is evaluated over 100 independent runs, following the statistical protocol of Benchmarking Quantum Reinforcement Learning. Its reported cost of roughly 12 minutes of simulation per 14-qubit run sets our compute budget, and density-matrix simulation will be more expensive still. We will therefore cap the main sweeps at about 10 qubits and state this.
Decisive check 1. Under uniform depolarizing noise, the learned $\lambda$ should grow approximately as $q^{-L}$, and expected return should be nearly preserved while required shots grow as $q^{-2L}$. Under amplitude damping, return should degrade even with $\lambda$ trained. If $\lambda$ does not track $q^{-L}$, the mechanistic account is wrong.
Decisive check 2. We trace the measured feasibility region in the plane of depth versus dispatch latency at each noise level, and compare it to the region predicted by the shot-latency bound. Agreement within the bound's slack validates the analysis as a design tool. Systematic disagreement means real decisions are dominated by something else, such as instance-dependent gaps.
Decisive check 3. Within the feasible region, the quantum head must beat the matched classical head on deadline-feasible utility with confidence intervals over 100 seeds. If it does not, the conclusion is that quantum assignment heads offer no benefit on this problem at any reachable operating point. Combined with the dispatch-latency axis, that conclusion would state precisely how far hardware must move before the question reopens.
References
- Parametrized Quantum Policies for Reinforcement Learning
- Joint Subcarrier and CPU Time Allocation for Mobile Edge Computing
- BCQQ: Batch-Constraint Quantum Q-Learning with Cyclic Data Re-uploading
- Unfolding WMMSE Using Graph Neural Networks for Efficient Power Allocation
- Variational Quantum Circuits for Deep Reinforcement Learning
- Characterization of Loss Mechanisms in a Fluxonium Qubit
- First Experience with Real-Time Control Using Simulated VQC-Based Quantum Policies
- QMaxCal: Path-Space Regularization for Open Quantum Control via Girsanov's Theorem
- Scaleable Quantum Control via Physics Constrained Reinforcement Learning
- Scalable Network Adaptation for Cloud-Rans: An Imitation Learning Approach
- Benchmarking Quantum Reinforcement Learning
- Multi-Agent Quantum Reinforcement Learning Using Evolutionary Optimization
- Quantum Imitation Learning