Pooling Turbulence Bins Across Receivers for Finite-Size Free-Space CV-QKD

Quantum key distribution (QKD) lets two parties grow a shared secret key whose security rests on physics rather than on computational hardness. When the quantum signals travel through open air, to a satellite, a drone, or across a bay, turbulence makes the fraction of light that arrives (the transmittance) flicker from moment to moment. In continuous-variable QKD, where key bits are encoded in the amplitude and phase of weak laser pulses, that flicker looks to the receiver like extra noise, and an eavesdropper could be hiding inside it. The best current fix sorts received samples into bins of similar instantaneous transmittance and estimates the channel separately inside each bin (Long-Distance Free-Space Quantum Key Distribution with Continuous Variables). That fix has a cost. Every bin holds only a slice of the data, and security proofs charge a statistical penalty that grows as the sample count per estimate shrinks. Over a short satellite pass or a drone flight, thin bins can erase the key.

We propose to remove that penalty by pooling bins across receivers rather than within one. Free-space links already use several receiving apertures or ground stations to fight fading (Exploiting Spatial Diversity in Earth-to-Satellite Quantum-Classical Communications). If every receiver sends its samples to whichever compute worker owns the matching transmittance bin, each bin gains roughly a factor of $M$ more samples, where $M$ is the number of receivers. This routing step has the same structure as the token shuffle in mixture-of-experts training, where each token goes to the processor holding its assigned expert, and it inherits the same problem: bins fill unevenly as the weather changes. We therefore build the shuffle as a two-level exchange, combining data inside each site before exchanging it between sites, adapted from Tutel: Adaptive Mixture-of-Experts at Scale. The aim is grouped processing that runs in real time across distributed hardware at finite block sizes.

Core Claim

In multi-receiver free-space CV-QKD, the finite-size loss caused by transmittance grouping is a sample-count problem, and redistributing samples across receivers by transmittance bin can solve it. The finite-size secret key from one pass, summed over bins $k$, behaves roughly as

$$ \ell \approx \sum_k n_k\left[\beta I_{AB}(k) - \chi_{BE}^{\uparrow}(k, n_k)\right] - O\!\left(\sqrt{\textstyle\sum_k n_k}\right). $$

Here $n_k$ is the number of samples in bin $k$, $\beta$ is the reconciliation efficiency, $I_{AB}(k)$ is the mutual information between the two parties in that bin, and $\chi_{BE}^{\uparrow}(k,n_k)$ is a confidence-bounded upper estimate of what an eavesdropper can learn. The confidence intervals on the estimated transmittance and excess noise shrink like $1/\sqrt{n_k}$, the standard sampling rate for variance estimators, so $\chi^{\uparrow}$ falls toward its asymptotic value as $n_k$ grows. Pooling replaces $n_k$ with $\sum_m n_k^{(m)}$ over receivers $m$. That shrinks the penalty in every bin, and it lets the system use finer bins, and so less fading noise, before thin bins begin to cost key.

Pooling is sound only if receivers that land in the same bin really share the same channel statistics. That is the same assumption single-link grouping already makes across time. We do not assume it. We test it per bin and fall back to conservative pooled bounds when it fails.

The second claim is about systems. Data that depends on transmittance arrives with heavy skew: most samples fall in a few mid-transmittance bins, and deep fades produce bursts of near-empty ones. A flat shuffle between receivers and bin-owning workers then breaks down in the way documented for skewed mixture-of-experts dispatch and for high fan-in I/O (Improving MPI Collective I/O for High Volume Non-Contiguous Requests With Intra-Node Aggregation). We claim a two-level exchange with bin-aware load balancing keeps the shuffle off the critical path. The critical path is the reconciliation decoder, whose single-GPU throughput is already a bottleneck at low signal-to-noise ratio (Key Reconciliation with Low-Density Parity-Check Codes for Long-Distance Quantum Cryptography).

Relation to Prior Work

Two papers motivate the proposal. Zhan et al. introduced transmittance grouping for a single 7-km and a single 9.6-km link. They ran it offline and named real-time finite-size processing as open. We keep their grouping idea and change where the samples come from. Wang et al. combine $M$ apertures optically with beam splitters before detection and report diminishing returns as $M$ grows. We instead detect at each aperture and combine digitally, at the level of statistics. That needs no phase alignment between apertures, and our gain comes from sample count rather than from averaging fields.

Three papers supply the systems method. Tutel splits a skewed all-to-all into an exchange inside each node followed by an exchange between nodes. TAM shows that local aggregators fix fan-in congestion, but only if aggregator density is tuned. That tuning trade-off reappears here as the question of how many bin-owners each site should host. Node-aware staging of irregular GPU messages (Characterizing the Performance of Node-Aware Strategies for Irregular Point-to-Point Communication on Heterogeneous Architectures) informs how small fade-bursts get coalesced.

Two papers sit nearby but differ in kind. CollComm buffers entangled pairs for distributed quantum computing over stationary channels, and Kaewpuang et al. allocate fiber QKD keys to federated learning. Neither touches the post-processing data path or fading.

Research Program

The work has three parts.

The first part is a pooled-grouping security analysis. For each bin it tests whether receivers' excess-noise estimates are statistically compatible, and it derives finite-size bounds for three cases: full pooling, partial pooling (shrinking each receiver's estimate toward the pool), and no pooling. Incompatible receivers are never naively merged. Receivers that operate as trusted nodes of one organization share one key, as in the multi-aperture setting.

The second part is the distributed pipeline itself. Each receiver tags samples with a transmittance estimate from its pilot or beacon. A site-level aggregator coalesces samples by bin. An exchange between sites then routes coalesced bins to their owners, with owners reassigned per frame according to observed bin occupancy. Each owner runs parameter estimation and a multi-edge low-density parity-check (LDPC) decoder of the kind in Milicevic et al..

The third part is a workload generator. Per-aperture transmittance traces are produced by phase-screen propagation, with aperture separation controlling how correlated the receivers' fades are. The fast learned simulator of Mao et al. is used for volume, and split-step propagation for validation. Link budgets are calibrated to the reported field conditions: losses under 25 dB on 7 to 9.6 km paths (Zhan et al.) and roughly 9 dB over a 200 m drone link (Drone-based quantum key distribution).

Baselines

The naive reference is ungrouped processing: the fading channel is treated as one stationary channel with a fixed-rate LDPC code. Zhan et al. report that this does not yield positive key under their daylight conditions. We run it on identical traces so the gap from grouping is measured rather than assumed.

The strongest existing method is per-receiver grouping as in Zhan et al., who report average secret key rates of 0.0560 to 2.3545 bps over 7 km and 0.0379 to 0.4768 bps over 9.6 km. To be fair, we tune its bin count per scenario with the same budget used for our method. Each receiver gets the same samples, decoder, and security-proof assumptions, and keys are summed across receivers. Beating it means a higher total finite-size key per pass at equal total samples, with the gap widening as pass duration shrinks.

The optical alternative is beam-splitter combining as in Wang et al., simulated on the same phase screens with ideal phase alignment. Ideal alignment gives it an upper-bound advantage.

On the systems side, the strongest single-machine reference is one GPU running the Milicevic et al. decoder, which reports 1.72 Mbit/s raw decoding throughput at rate 0.02. Two ablations isolate the shuffle. The first is a flat all-to-all with the same bin owners. The second is a two-level exchange with static bin ownership, which isolates the load balancing. For reference, Tutel reports a 5.75x speedup from its two-level exchange at 2,048 GPUs on mixture-of-experts layers. No reported result was found on Lacuna for hierarchical shuffling of QKD data. A final ablation, pooling without the compatibility test, isolates the statistical safeguard.

Why not just…?

Why not just use fewer, wider bins at a single receiver? This is the most serious competitor, because wider bins also raise $n_k$. It pays for that with more residual fading noise inside each bin, while pooling raises $n_k$ without widening bins. We settle the question by sweeping bin count for both methods and comparing the best point each can reach. If the single-receiver optimum matches pooling, the statistical claim fails and we say so.

Why not just accumulate data over a longer time? For a fixed link, more passes do increase samples. However, satellite overpasses and drone flights bound the block size, and finite-key rather than asymptotic operation is exactly the open regime Zhan et al. identify. We report key from one pass as a function of pass length, which shows directly where accumulating over time is unavailable.

Why not just ship everything to one server? For co-located apertures at modest symbol rates this may well suffice, and then the systems contribution reduces to the pooling statistics alone. We measure the crossover in aggregate raw-quadrature ingest rate and number of sites at which one node stops keeping up. Below that crossover we recommend centralization.

Why not just use rateless codes that adapt to SNR? Spinal codes keep reconciliation efficiency near 95% across a wide SNR range (Wen et al.). They fix decoding efficiency, not the parameter-estimation penalty, and they are complementary to pooling. We include a spinal-code variant within each owner.

Proposed Experiments

We simulate $M \in \{1,2,4,8,16\}$ receivers across inland, maritime, and drone-like regimes, from weak to strong turbulence, with pass lengths from seconds to minutes. Metrics are finite-size secret bits per pass, the fraction of bins with positive key, end-to-end latency relative to symbol arrival, and the share of each frame spent in the shuffle versus the decoder. Systems runs use a GPU cluster with emulated wide-area latency between sites.

Four checks decide the outcome. First, at equal total samples, pooled grouping must beat per-receiver grouping, with both bin counts optimized, and the gain must grow as passes shorten. Second, when aperture noise is made deliberately heterogeneous, the compatibility test must stop pooling from producing keys that the per-receiver bound would reject. Third, under skewed bin occupancy in strong turbulence, the load-balanced two-level exchange must keep shuffle time below decoder time where the flat exchange does not. Fourth, the full pipeline must sustain real-time processing at symbol rates where a single decoder falls behind.