The Quantum IO Monad

The publication in 1994 of Shor's algorithm, which allows factorization of composite number N in a time polynomial in its binary length L has been the primary catalyst for the race to construct a functional quantum computer. However, it seems clear that any practical system that may be developed will not be able to perform completely error free quantum gate operations or shield even idle qubits from inevitable error effects. Hence, the practicality of quantum algorithms needs to be investigated to estimate what demands must be made of quantum error correction (QEC). Several different quantum circuits implementing the quantum period finding (QPF) subroutine, which lies at the heart of Shor's algorithm have been designed, but each tacitly assumes that arbitrary pairs of qubits can be interacted. While some architectures posses this property, many promising proposals are best suited to realizing a single line of qubits with nearest neighbor interactions only. This paper will present a circuit suitable for implementing the QPF subroutine for such linear nearest neighbor (LNN) designs. We will then present direct simulation results showing for both the LNN circuit and for a circuit utilizing arbitrary interactions, that the QPF subroutine is very sensitive to a small number of errors in the entire circuit. These results can then be used to briefly examine some of the practical issues to implementing such large scale quantum algorithms.

This introduction to quantum computing from a classical programmer's perspective is meant for students and practitioners alike. More than 50 quantum techniques and algorithms are explained with mathematical derivations and code for simulation, using an open-source code base in Python and C++. New material throughout this fully revised and expanded second edition includes new chapters on Quantum Machine Learning, State Preparation, and Similarity Tests. Coverage includes algorithms exploiting entanglement, black-box algorithms, the quantum Fourier transform, phase estimation, quantum walks, and foundational QML algorithms. Readers will find detailed, easy-to-follow derivations and implementations of Shor's algorithm, Grover's algorithm, SAT3, graph coloring, the Solovay-Kitaev algorithm, Moettoenen's algorithm, quantum mean, median, and minimum finding, Deutsch's algorithm, Bernstein-Vazirani, quantum teleportation and superdense coding, the CHSH game, and, from QML, the HHL algorithm, Euclidean distance, and PCA. The book also discusses productivity issues like quantum noise, error correction, quantum programming languages, compilers, and techniques for transpilation.

The effects of imperfect gate operations in implementation of Shor's prime factorization algorithm are investigated. The gate imperfections may be classified into three categories: the systematic error, the random error, and the one with combined errors. It is found that Shor's algorithm is robust against the systematic errors but is vulnerable to the random errors. Error threshold is given to the algorithm for a given number N to be factorized.

Random number generation is a fundamental aspect of computer science, cryptography, simulations, and statistical sampling. This paper explores the definitions, classifications, and implementations of random and pseudo-random number generators (RNGs and PRNGs). We examine true random number generators (TRNGs), which derive randomness from physical phenomena, and pseudo-random number generators (PRNGs), which use deterministic algorithms to produce sequences that mimic randomness. Case studies, including Random.org, HotBits, laser-based RNGs, and the Linux random number generator, illustrate practical implementations. We also discuss vulnerabilities, security considerations, and the importance of entropy in generating unpredictable sequences.

Much scientific work has focused on the generation of random numbers as well as the distribution of said random numbers for use as a cryptographic key. However, emphasis is often placed on one of the two to the exclusion of the other, but both are often simultaneously important. Here we present a simple hybrid free-space link scheme for both the generation and secure distribution of (pseudo-)random numbers between two remote parties, drawing the randomness from the stochastic nature of atmospheric turbulence. The atmosphere is simulated using digital micro-mirror devices for efficient, all-digital control. After outlining one potential algorithm for extracting random numbers based on finding the centre-of-mass (COM) of turbulent beam intensity profiles, the statistics of our experimental COM measurements is studied and found to agree well with the literature. After implementing the scheme in the laboratory, Alice and Bob are able to establish a string of correlated random bits with an 84% fidelity. Finally, we make a simple modification to the original setup in an attempt to thwart the hacking attempts of an eavesdropper, Eve, who has access to the free-space portion of the link. We find that the fidelity between Eve’s key and that of Alice/Bob is 54%, only slightly above the theoretical minimum. Atmospheric turbulence could hence be leveraged as an added security measure, rather than being seen as a drawback.

The standard approach to fault-tolerant quantum computation is to store\ninformation in a quantum error correction code, such as the surface code, and\nprocess information using a strategy that can be summarized as\ndistill-then-synthesize. In the distill step, one performs several rounds of\ndistillation to create high-fidelity logical qubits in a magic state. Each such\nmagic state provides one good T gate. In the synthesize step, one seeks the\noptimal decomposition of an algorithm into a sequence of many T gates\ninterleaved with Clifford gates. This gate-synthesis problem is well understood\nfor multiqubit gates that do not use any Hadamards. We present an in-depth\nanalysis of a unified framework that realises one round of distillation and\nmultiqubit gate synthesis in a single step. We call these synthillation\nprotocols, and show they lead to a large reduction in resource overheads. This\nis because synthillation can implement a general class of circuits using the\nsame number of T-states as gate synthesis, yet with the benefit of quadratic\nerror suppression. This general class includes all circuits primarily dominated\nby control-control-Z gates, such as adders and modular exponentiation routines\nused in Shor's algorithm. Therefore, synthillation removes the need for a\ncostly round of magic state distillation. We also present several additional\nresults on the multiqubit gate-synthesis problem. We provide an efficient\nalgorithm for synthesizing unitaries with the same worst-case resource scaling\nas optimal solutions. For the special case of synthesizing\ncontrolled-unitaries, our techniques are not just efficient but exactly\noptimal. We observe that the gate-synthesis cost, measured by T-count, is often\nstrictly subadditive. Numerous explicit applications of our techniques are also\npresented.\n

Monte Carlo (MC) method is widely used in resolving mathematical problems that are too complicated to solve analytically. The method involves with sampling process of the random numbers and probability to estimate the result. As MC method depending on a large number of good quality random numbers to produce a high accuracy result, developing a good random number generator (RNG) is vital. Most of random number generators are developed in software based, with the improvement of Field Programmable Gate Arrays (FPGA) density and speed in recent days, implementing random number generator (RNG) directly into hardware is feasible. Random Walk on the Boundary (WOB) is one of MC methods that applied to calculate the unit cube capacitance. The unique requirement of this method is the random numbers produced by RNG must fall within the Gaussian distribution and the maximum decimal values in the range of [0, 1]. Thus, in this paper we presented a novel hardware RNG for Random WOB method to calculate unit cube capacitance in FPGA. The RNG is implemented in floating-point base, using the combination of Cellular Automata Shift Register (CASR) and Linear Feedback Shift Register (LFSR) then channeled through Box-Muller transformation. There is linear approximation in computing logarithmic function applied in Box-Muller transformation. Based on statistical tests, the random numbers generated is nearly 97.5% resembling the standard normal distribution.

Transversality is a simple and effective method for implementing quantum computation fault-tolerantly. However, no quantum error-correcting code (QECC) can transversally implement a quantum universal gate set (Eastin and Knill, {\em Phys. Rev. Lett.}, 102, 110502). Since reversible classical computation is often a dominating part of useful quantum computation, whether or not it can be implemented transversally is an important open problem. We show that, other than a small set of non-additive codes that we cannot rule out, no binary QECC can transversally implement a classical reversible universal gate set. In particular, no such QECC can implement the Toffoli gate transversally.}{We prove our result by constructing an information theoretically secure (but inefficient) quantum homomorphic encryption (ITS-QHE) scheme inspired by Ouyang {\em et al.} (arXiv:1508.00938). Homomorphic encryption allows the implementation of certain functions directly on encrypted data, i.e. homomorphically. Our scheme builds on almost any QECC, and implements that code's transversal gate set homomorphically. We observe a restriction imposed by Nayak's bound ({\em FOCS} 1999) on ITS-QHE, implying that any ITS quantum {\em fully} homomorphic scheme (ITS-QFHE) implementing the full set of classical reversible functions must be highly inefficient. While our scheme incurs exponential overhead, any such QECC implementing Toffoli transversally would still violate this lower bound through our scheme.

The cryptographic security provided by various techniques of random number generator (RNG) construction is one of the developing research areas today. Among various types of RNG, the true random bit generator (TRBG) can be considered as the most unpredictable and most secure because its randomness seed is generated from chaotic sources. This paper proposes a design of TRBG model based on double-scroll attractors circuits with GST memristor. After implementation and simulation of the chaotic circuit with GST memristor emulator, the chaotic behavior of the output voltage and inductor current were received. Moreover, their dependence on the input voltage revealed the close to double-scroll form. The randomness generated from the proposed circuit was tested by analysis of the Fast Fourier Transform (FFT) and Lyapunov exponents of the output voltage.

We demonstrate a 6 Gbps real-time optical quantum random number generator by measuring vacuum fluctuation. To address the common problem that speed gap exists between fast randomness generation and slow randomness extraction in most high-speed real-time quantum random number generator systems, we present an optimized extraction algorithm based on parallel implementation of Toeplitz hashing to reduce the influence of classical noise due to the imperfection of devices. Notably, the real-time rate of randomness extraction we have achieved reaches the highest speed of 12 Gbps by occupying less computing resources, and the algorithm has the ability to support hundreds of Gbps randomness extraction. By assuming that the eavesdropper with complete knowledge of the classical noise, our generator has a randomness generation speed of 6.83 Gbps and this supports the generation of 6 Gbps information-theoretically provable quantum random numbers, which are output in real-time through peripheral component interconnect express interface.

Chapter 3 - Random Number Generation

Approximation errors must be taken into account when compiling quantum programs into a low-level gate set. We present a methodology that tracks such errors automatically and then optimizes accuracy parameters to guarantee a specified overall accuracy while aiming to minimize the implementation cost in terms of quantum gates. The core idea of our approach is to extract functions that specify the optimization problem directly from the high-level description of the quantum program. Then, custom compiler passes optimize these functions, turning them into (near-)symbolic expressions for (1) the total error and (2) the implementation cost (e.g., total quantum gate count). All unspecified parameters of the quantum program will show up as variables in these expressions, including accuracy parameters. After solving the corresponding optimization problem, a circuit can be instantiated from the found solution. We develop two prototype implementations, one in C++ based on Clang/LLVM, and another using the Q# compiler infrastructure. We benchmark our prototypes on typical quantum computing programs, including the quantum Fourier transform, quantum phase estimation, and Shor's algorithm.

This paper presents the FPGA (Field Programmable Gate Array) implementation and the coupling analysis of a metastability-based random number generator (RNG). The metastability is acquired through exploiting transient effect ring oscillators (TEROs) and the random bit generation is accomplished through irregular sampling of regular waveform method. As the proposed RNG is made up of only digital logic gates, it is prototyped on a Xilinx ZedBoard Zynq-7000 evaluation platform. It is demonstrated that the RNG output bitstream satisfies NIST 800-22 statistical tests of randomness without any need for post-processing and the proposed RNG can provide high data throughput. Furthermore, the proposed RNG uses less number of components compared to previously reported TERO based RNGs, thus enabling lower power consumption and smaller footprint. Additionally, the proposed RNG is subjected to correlation based cryptanalysis study. In classical ring oscillator (RO) based RNGs, the ring oscillators are required to be placed at a distance from each other to avoid locking phenomenon that may occur due to coupling between adjacent ROs. This study demonstrates that unlike classical RO based RNGs, the proposed RNG is insensitive to locking phenomenon and TERO structures are not required to be placed way from each other. Therefore, the proposed method lead to a more compact RNG design compared to classical RO based RNGs.

This study introduces a novel approach to address the limitations observed in existing random number generator (RNG) designs, focusing on the resolution for insufficiently covered problem statements and study purposes. In response to these challenges, we propose a high-throughput metastable-based RNG tailored for cryptography applications. Our design is featured with a two-layer transient effect ring oscillator (TERO) architecture, meticulously crafted to mitigate the locking phenomenon and enhance RNG randomness. Leveraging interleaved two-layer TEROs, realised through NAND and NOR SR latches, our RNG achieves unpredictable irregular sampling, crucial for cryptographic applications. To further enhance irregular sampling, the first layer of the RNG employs a multiplexer that selects inputs randomly. This multiplexer is governed by selection signals generated by the second layer of the RNG, ensuring superior randomness. Implemented using TSMC 40-nm CMOS process, our RNG passed the FIPS 140–1 randomness test at a clock frequency of 100 MHz, boasting a remarkable throughput of 50 Mbps. This study represents a significant advancement in RNG technology, addressing previous shortcomings and paving the way for high-speed communication systems’ secure cryptographic applications.

This study presents the algebraic cryptanalysis of a continuous‐time chaotic random number generator (RNG) based on a Zhongtang chaotic system. The chaos‐based RNG provides key values for logic encryption, round key formation and the substitution box (S‐box) generation steps in AES (advanced encryption standard). In this study, an attack method is proposed to exploit the weaknesses of the chaos‐based RNG used in this cryptographic system. By observing a chaotic state variable and knowing the structure of the target RNG, output bit sequence of the target RNG is reproduced by a clone RNG used in master–slave synchronisation scheme. The feasibility of the attack system is confirmed through simulation and numerical results. Through this attack method, the same S‐box parameters and key values can be obtained which can be used for decryption of the proposed encryption algorithm. This study targets a specific continuous‐time chaos‐based RNG and the associated cryptographic system as a case study. However, the cryptanalysis method described in this study is applicable to any continuous‐time or discrete‐time chaos‐based RNGs. Therefore, this study highlights the security vulnerabilities of chaos‐based RNGs and emphasises that deterministic chaos phenomena itself should not be considered as the actual source of randomness.