Software-defined quantum communication

Controlling quantum optical metadata with a classical programming paradigm allows rapid prototyping of quantum communication testbeds.
29 July 2013
Travis Humble

Quantum information technology promises new techniques for communication, such as teleportation, super-dense coding, and perfect cryptographic security.1 Prototyping quantum communication systems is an important part of confirming these predictions and assessing possible experimental performance. However, efforts to build complete quantum communication systems are time-intensive tasks that require expertise across optical, electrical, and software engineering domains. Laboratory setups for proof-of-principle experiments are often constructed from scratch, while first-generation commercial systems are fixed designs tuned for performance with little room for modification. Methods to easily and quickly prototype new protocols are needed for exploring the large design space that defines quantum communication.

There are emerging methods for lowering barriers to system prototyping in the field of conventional communication. Software-defined communication (SDC) has proven especially useful for developing flexible designs for radio systems. SDC allocates tasks that usually require specialized hardware to software implementations that can be tuned through reprogramming.2 Although the underlying physics is different, the SDC paradigm applies to building quantum communication systems as well. This is because both quantum and classical domains employ many of the same processing primitives at the information (bit) and metadata level. De/modulation and de/coding techniques are required for individual transmissions as well as the handshaking exchanges needed to negotiate complete protocols in both domains. These common needs motivate our consideration of software-defined quantum communication (SDQC).

The SDQC methodology formalizes how the different functional layers in a quantum communication system are defined and developed. An example SDQC framework is shown in Figure 1, where the terminals of a transmitter-receiver (TX-RX) pair are decomposed in terms of functional domain layers. These layers define the physical hardware, the software protocol, and the mitigating middleware, with each layer providing a natural separation of functional concerns that can be independently tuned from the others. For quantum communication, this translates into a separation of the low-level preparation and detection of quantum optical states from the high-level abstraction of qubits and projection operators.3

Figure 1. The different layers in a software-defined quantum communication system. TX: Transmitter. RX: Receiver.

As an example, we have employed the SDQC methodology in the development of an entanglement distribution system. Entanglement distribution is a task common to quantum teleportation, super-dense coding, and other quantum communication protocols. It operates by distributing entangled qubits between the TX and RX, which monitor the visibility of measured correlations as a form of channel diagnostic.

The TX hardware layer consists of a transmitter that distributes each photon to a remote RX (see Figure 2). The source, based on continuous wave pumping of spontaneous parametric down conversion, couples each photon into a single-mode fiber that together serve as the quantum channel. The RX hardware layer is built from a Michelson interferometer that uses a variable arm to scan the path length of the long arm. The RX hardware also consists of single photon counting modules that output an electrical pulse when a photon is detected. The middleware is represented by a field programmable gate array-based timestamping module that records photon arrival time.4 These timestamps represent the metadata generated by the middleware layer, which then broadcasts the data to a host computer client.

Figure 2. A schematic of the entanglement distribution system with its hardware, middleware, and software layers highlighted.

The software layer is expressed by a host computer running a real-time signal processing program that collects the data broadcasts. Our program has been developed based on QITKAT, an extension to the GNU Radio signal processing library that includes processing blocks for prototyping stream-based quantum communication.5 Blocks for parsing and exchanging timestamp data as well as computing bit-wise correlations and bit error rates are part of the library. QITKAT also interfaces with the middleware via low-level system calls to system sockets from within the block definitions. These details, however, are abstracted as primitive processing statements more relevant for system prototyping. A software developer programming against the provided interface defers the hardware control details to the middleware developer.

An example of a QITKAT program for calculating the mutual entropy between two measurement series originating from different terminals is shown in Figure 3. The graphical interface illustrates the relative simplicity with which changes to the processing protocol can be made. At the moment, QITKAT is limited to collecting and processing measurement data, but we anticipate forward control functionality using extensions to the middleware design. The SDQC methodology separates the concern for how control is accomplished from how the programmer uses that control.

Figure 3. The graphical interface provided by GNU Radio and used by QITKAT for developing user-defined programs. BER: Bit error rate.

Software-defined quantum communication shifts the burden of designing new protocols from hardware to software developers. It decreases the time to prototype a communication system and increases the reuse of hardware investments. We expect the multi-layer functional decomposition will become more pronounced as quantum communication matures. As quantum services become integrated with conventional communication, it will be increasingly important to abstract away the quantum physical hardware.3 This is likely to mimic the way conventional communication relies on a protocol stack, which can be viewed as an extension of the terminal decomposition given here. The SDQC methodology we have outlined is only the beginning of this multi-layered development. The next steps will include using SDQC to prototype communication protocols for quantum key distribution and super-dense coding as well as refining the interfaces between the various layers.

The author is grateful for the support of the Defense Threat Reduction Agency and the technical support of the following Oak Ridge National Laboratory personnel: (hardware) Brian Williams, Duncan Earl, and Warren Grice; (middleware) Dave Richardson, Laura Ann Anderson, Toby Flynn, Ali Ismail, Kenyon Clark, Ben Hey, and Austin Albright; (software) Alex McCaskey and Ron Sadlier. This manuscript has been authored by UT-Battelle LLC under contract DE-AC05-00OR22725 with the US Department of Energy.

Travis Humble
Oak Ridge National Laboratory (ORNL)
Oak Ridge, TN

Travis Humble, senior scientist and co-director of the ORNL Quantum Computing Institute, is also an assistant professor with the University of Tennessee. His research includes quantum information, high-performance signal processing, and software-defined communication.

1. M. M. Wilde, From Classical to Quantum Shannon Theory, Cambridge University Press, 2013.
2. J. Mitola, Cognitive Radio: An Integrated Agent Architecture for Software-Defined Radio, PhD thesis, Royal Institute of Technology, Kista, Sweden, 2000.
3. T. S. Humble, Quantum security for the physical layer, IEEE Wireless Commun. August, 2013.
4. R. C. Pooser, D. D. Earl, P. G. Evans, B. Williams, J. Schaake, T. S. Humble, FPGA-based gating and logic for multichannel single photon counting, J. Modern Opt. 59, 2012.
5. Open-source software development toolkit for software radios. Accessed 7 July 2013.
Sign in to read the full article
Create a free SPIE account to get access to
premium articles and original research
Forgot your username?